feat(connections): connect services from native task feeds (#13058)

## Thinking Path

> - Paperclip is the open source app people use to manage AI agents for
work
> - Agents use connections to reach external services.
> - A fresh native task can have no service tools installed.
> - The agent needs a way to discover services and ask the responsible
person for access.
> - This pull request brings the existing connection-intent flow into
native task execution.
> - The person can connect from the task, and the agent can continue
with updated tools.

## Linked Issues or Issue Description

**Subsystem affected**

Native runner tool authority, connection intents, task interactions, and
shared connection setup.

**Problem or motivation**

A task that needs an unconnected service cannot finish its work. Leaving
the task to configure access also loses context. A resolved request must
survive a restart and resume the correct agent once.

**Proposed solution**

Expose connection discovery and access requests as server-owned native
tools. Render a durable task card and use the shared setup dialog.
Persist outcome delivery and start a fresh provider session after access
is ready.

**Alternatives considered**

Sending the person to the Connections page adds navigation and does not
solve continuation. Polling for authorization consumes runs and can
create duplicate requests.

**Roadmap alignment**

This extends the existing connection-intent runtime and setup
experience. It reuses the shared access model and the native runner.

Related: #12345, #12347. The service-slug fix in #12906 is related but
separate. Companion evaluation PR:
https://github.com/paperclipai/paperclip-evals/pull/21.

## What Changed

- Expose `connections_search` and `connection_request` with server-bound
company, task, agent, and responsible user. Preserve the legacy entry
points.
- Discover catalog services and authorized custom connections. Check
installation, identity, health, and executable permissions before
reporting ready.
- Keep pending cards through ordinary messages. Reuse requests and
retire stale ownership. Put Connect at the right of Not now.
- Reuse the shared setup flow in a task dialog. Keep access additive and
default to the requesting agent. Recover from cancelled or blocked OAuth
windows with a new-tab fallback.
- Persist outcome delivery with an idempotent wake key. Resume in a
fresh session and recheck ownership before dispatch.
- Add native browser fixtures, offline Storybook states, server
contracts, and evaluation fixtures. Update guidance and documentation.

## Verification

- `pnpm build`: passed after replaying the change on current master.
- `pnpm -r typecheck`: passed.
- `pnpm check:token-gates`: passed.
- `pnpm --filter @paperclipai/ui build-storybook`: passed.
- New continuation-policy regression cases: 16 passed.
- Docker-backed PostgreSQL regressions passed for requester-only OAuth
access, assignment-only expiry, terminal expiry, and credential-free
setup metadata.
- Shared setup and task-card UI tests: 121 passed, including configured
MCP reconnect URL recovery and preserving user edits across refetch.
- Storybook browser checks: all 119 passed on the latest reconnect fix.
- `pnpm test:run`: 4,734 tests passed in the first server group, but
embedded PostgreSQL startup failures and resulting cleanup errors
prevented a complete local pass. All Linux CI lanes passed on the latest
reviewed commit. One external-object route test returned an unexplained
500 on the first run; it passed twice locally and the failed shard
passed on retry without code changes.
- Earlier feature-checkout evidence: three deterministic native browser
journeys passed, including restart delivery and an actual fixture tool
result. Legacy scripted coverage also passed. All 59 added stories were
inspected in light and dark themes.
- Live Notion testing recorded successful provider reads. The manual
test used a local-trusted instance. It does not prove
authenticated/cloud deployment or every provider journey.
- Native browser rerun reached the embedded PostgreSQL startup limit
before bootstrap, so the latest checkout’s full native browser journey
remains unverified. Both OAuth page/task regression cases passed against
isolated Docker-backed PostgreSQL 17. They verify no premature task
access, requester-only completion, additive retries, and reconnect
preservation.
- Applied both new migrations twice to isolated PostgreSQL 17. Foreign
keys remained intact, duplicate active delivery keys were rejected, and
failed delivery records did not block retries.

Reviewer path: start a fresh test drive, enable the native runner, use
an agent that can perform work directly, and ask it to summarize a
Notion page. Connect from the card, then verify the resumed provider
call and source-linked answer. The default test-drive CEO is instructed
to delegate, so it can introduce an unrelated hiring step.

## Risks

- Two additive migrations create durable deliveries and a partial unique
wake index. They are idempotent. The wake index can require a
maintenance window on large tables because migrations run in a
transaction.
- OAuth and continuation cross asynchronous boundaries. Tests cover
ownership changes, retries, additive access, and restart delivery; live
provider behavior still varies.
- The latest requester-scope fix has not yet been exercised through live
OAuth. GitHub, API-key, authenticated-user, and all recovery journeys
are not claimed as verified.

## Model Used

OpenAI GPT-6-based Codex assisted with implementation, tests, and review
using tools and code execution. The runtime does not expose the exact
model version, context window, or reasoning setting. Live evaluation
used `gpt-5.6-luna`; manual native testing used `gpt-5.6-sol`.

## Checklist

- [x] I have included a thinking path that traces from project context
to this change
- [x] I have specified the model used and disclosed unavailable runtime
details
- [x] I have checked ROADMAP.md and confirmed this extends existing
connection work
- [x] I have searched GitHub for duplicate or related PRs and linked
them above
- [x] I have described the issue in-PR following the feature issue
template
- [x] I have not referenced internal or instance-local Paperclip issues
or links
- [x] My branch name describes the change and contains no internal
ticket id
- [ ] I have run all required tests locally and they pass
- [x] I have added or updated tests where applicable
- [x] I have updated relevant documentation
- [x] I have considered and documented risks
- [x] All Paperclip CI gates are green
- [x] Greptile is 5/5 with no open P2s, recommendations, or follow-ups
- [x] I will address all Greptile and reviewer comments before
requesting merge

---------

Co-authored-by: Paperclip <noreply@paperclip.ing>

cli/tsconfig.json

@@ -4,5 +4,5 @@
     "outDir": "dist",
     "rootDir": ".."
   },
-  "include": ["src", "../packages/shared/src", "../packages/plugins/create-paperclip-plugin/src"]
+  "include": ["src", "../packages/shared/src", "../server/src/types/express.d.ts", "../packages/plugins/create-paperclip-plugin/src"]
 }

doc/connection-intents.md

@@ -15,10 +15,12 @@ Provider-specific setup must stay in the shared feature and `AppDefinition` meta
 
 Every active heartbeat with a responsible user receives two run-bound tools:
 
-- `connections_search({ query })` searches first-party connectable definitions and returns `ready`, `needs_user_action`, `available`, or `unavailable` from the requesting agent's perspective.
-- `connection_request({ service })` returns immediately when the service is already usable. Otherwise it creates or reuses a `connection_intent` and instructs the agent to end the run pending continuation.
+- `connections_search({ query })` searches catalog names and descriptions, plus authorized configured MCP connections and indexed tool descriptions and returns `ready`, `needs_user_action`, `available`, or `unavailable` from the requesting agent's perspective.
+- `connection_request({ service })` returns immediately when the service is already usable. Otherwise it creates or reuses a `connection_intent` and instructs the agent to finish independent work, then yield pending continuation.
 
-Claude and Codex receive the tools through a native managed MCP server. Local/process adapters receive `PAPERCLIP_RUNTIME_TOOLS_*` environment variables and CLI guidance. Cloud, HTTP, gateway, and external adapters receive the typed runtime descriptor in their invocation context; compatible adapters may also project it into their remote environment.
+The native Paperclip Runner advertises both tools through its server-owned tool authority even with an empty MCP assignment. It captures the current responsible identity at each call. Legacy Claude and Codex receive the tools through a managed MCP server. Local/process adapters receive `PAPERCLIP_RUNTIME_TOOLS_*` environment variables and CLI guidance. Cloud, HTTP, gateway, and external adapters receive the typed runtime descriptor in their invocation context; compatible adapters may also project it into their remote environment.
+
+Legacy delivery uses the same intent service, setup card, and fresh-session resolution wake. Environment and descriptor delivery require the receiving harness to consume them; they do not establish support in every third-party runtime. The default legacy prompt includes the canonical discovery guidance. A custom `promptTemplate` replaces that default and should retain the connection guidance if proactive discovery is desired.
 
 The equivalent CLI helpers are:
 
@@ -31,14 +33,46 @@ The manually configured Paperclip MCP server also advertises `connections_search
 
 ## Security and lifecycle
 
-- Company, agent, run, task, and responsible user come only from the signed runtime token and stored heartbeat context.
+- Company, agent, run, task, and responsible user come only from the signed legacy runtime token or the native server-owned binding and stored execution identity.
 - Tokens are scoped to connection intents, expire after one hour, and are rejected when the heartbeat is no longer running.
 - The thread payload contains only service identity, requesting-agent identity, and a safe phase. It never contains credentials or authorization URLs.
 - OAuth state is linked to the interaction. The same-origin callback finalizes the existing connection pipeline, posts only interaction ID/outcome to its opener, and redirects back to the task if there is no opener.
 - Personal OAuth defaults to the addressed user and creates an explicit delegation to the requesting agent. Reuse and installs are additive.
 - Task-hosted setup locks install reach to the requesting agent; the store host retains its normal broader access choices.
 - The intent resolves only after the connection, grant/delegation, profile access, and install succeed. Failures remain pending with `needs_retry`.
-- Closing the task, a newer run requesting the same service, or a newer human task comment expires the intent and deletes linked OAuth state.
-- Success and decline wake the assignee once using an interaction-and-status idempotency key and force a fresh continuation session.
+- Closing or reassigning the task expires pending intents and deletes linked OAuth state. Ordinary comments and later runs preserve the pending card. Requests reuse the same task, requester, addressed user and service; a different addressed user supersedes an older request for that service.
+- Success and explicit decline atomically persist a continuation delivery with resolution. A leased startup/periodic worker dispatches through heartbeat with a unique `connection-intent:<interaction>:<outcome>` wake key. It checks assignment, status, membership and current executable access, retries paused/suppressed delivery, and recovers a crash after enqueue without creating a second wake. The continuation forces a fresh provider session; heartbeat queues it behind active execution.
 
 Legacy `request_confirmation.payload.connectionAuthorization` interactions remain readable and resolvable. New agent requests use `connection_intent` exclusively.
+
+## Model evaluations
+
+The companion `paperclip-evals` repository owns the connection cases in
+`evals/runner-api-tools/connection-cases.json`. They use the existing real-server
+API-tool eval controller and `scripts/runner-api-eval-worker.ts`, with this
+checkout's production tool definitions, connection guidance, and authority.
+Natural prompts measure discovery and request selection; explicit contract probes
+measure deduplication, readiness, and denied targets. The fixture helper supplies
+isolated company records and retains initial and final connection interaction
+state. Scoring requires observed calls/results and persisted state, not an
+assistant's claim of having connected.
+
+These tool evals do not perform live provider OAuth or establish browser quality.
+The native and legacy connection browser suites separately cover setup and
+continuation, while the live-provider journey report records actual authorization
+and data-read coverage.
+
+
+## Custom targets, readiness and recovery
+
+Catalog slugs remain stable. Search also returns `connection:<uuid>` for configured custom connections whose active identity grants authorize the responsible person, their company, or the requesting agent. Identifiers are never interpreted as URLs. Configured metadata and tool descriptions, including catalog-provider descriptions, are read only after the company and identity audience checks. Setup choices expose only display and selection metadata; they never include connection configuration, transport settings, or credential fields. Discovery reads the stored index without refreshing providers. Search is ranked with exact provider matches first and capped at 20 results.
+
+`ready` requires an installed, enabled, healthy executable connection, permitted catalog tools, and a usable runtime identity. An installed connection with denied actions is administrative denial rather than a request to reauthenticate. Runtime calls continue enforcing access after a historical card resolves. If access is ready but the native provider's pinned tool snapshot is older, `connection_request` queues a fresh session without another authorization card.
+
+Task setup defaults to personal identity when supported and the requesting agent's install reach. Existing installs are additive. An OAuth callback from a task prepares the catalog without adding access. Intent completion validates the current task and identity, then adds the requesting agent’s binding and install in the resolution transaction. Callback messages do not establish authorization: the card reloads the durable server result. A blocked popup offers a new-tab fallback; closing or declining provider sign-in keeps the request retryable. Only the card's **Not now** action declines the request. Decline continuations are told to pursue alternatives and cannot immediately request the same service again.
+
+## Verification
+
+Service and native-authority tests cover discovery, current identity, company boundaries, cross-run deduplication, additive grants and installs, permission denial, resolution atomicity, restart delivery and stale assignment. `tests/e2e/in-feed-native/playwright.config.ts` starts source `test-drive` instances with fresh data directories and a deterministic fake Codex provider plus MCP server. It exercises the real native runner and gateway; it is fixture proof, not live Notion or GitHub proof. Run with `pnpm exec playwright test -c tests/e2e/in-feed-native/playwright.config.ts`.
+
+Offline Storybook examples live in `ui/storybook/stories/in-feed-connections.stories.tsx`. Build with `pnpm --filter @paperclipai/ui build-storybook`, then run `pnpm exec playwright test -c tests/storybook-visual/in-feed-connections.config.ts`. The suite checks every independently addressable story in both themes, catches play-function failures, and saves screenshots. Live provider acceptance additionally requires a model credential and a test workspace/account; do not describe fixture results or local-trusted testing as authenticated/cloud acceptance.

doc/design/COMPONENT-INVENTORY.md

@@ -404,3 +404,16 @@ Per-component rationale:
 ### 7.3 Interactive-card affordance (Run 3 review feedback)
 
 `Card` gained an `interactive` prop — pointer cursor, quiet hover (border→foreground/20 + shadow-md lift), focus-visible ring — used when the whole card is a click target (e.g. Companies selector). Skills tiles (CompanySkills `SkillCard`) and artifact cards (`ArtifactCard`/`ArtifactGroupCard`) apply the same recipe verbatim since they cannot render through Card (button/Link semantics). Static container Cards stay affordance-free by design.
+
+
+## In-task connections — 2026-09-07
+
+| Reusable surface | Production owner | Hosts / coverage |
+|---|---|---|
+| Connection request card | `ui/src/features/connections/ConnectionIntentInteractionBody.tsx` | Task timeline, interaction card, design guide; pending, reuse, authorizing, retry, resolved, audience and error stories |
+| Connection setup flow | `ui/src/features/connections/ConnectionSetupFlow.tsx` | Connections page and task dialog share provider forms, OAuth, validation and additive installs |
+| OAuth handoff | `OAuthConnectStateScreen` in the shared setup module | Entry, starting, open window, blocked popup, closure, callback failure, retry and new-tab fallback |
+| Identity and agent access | `AccessStep` in the shared setup module | Personal, organization, dedicated agent, unavailable identity and loading; task host fixes install reach to the requester |
+| Setup completion | `ConnectionSetupCompletionScreen` in the shared setup module | Page and dialog; identity, granted agent access and enabled actions |
+
+Independently addressable examples live under `Connections/In-task connections` in Storybook. The task composer remains available while a card is pending. These components use the existing token and primitive layers.

packages/db/src/migrations/0246_nostalgic_medusa.sql

@@ -0,0 +1,19 @@
+CREATE TABLE IF NOT EXISTS "connection_intent_deliveries" (
+	"interaction_id" uuid PRIMARY KEY NOT NULL,
+	"company_id" uuid NOT NULL,
+	"next_attempt_at" timestamp with time zone DEFAULT now() NOT NULL,
+	"delivered_at" timestamp with time zone,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL
+);
+--> statement-breakpoint
+DO $$ BEGIN
+  IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'connection_intent_deliveries_interaction_id_issue_thread_interactions_id_fk'::name AND conrelid = 'public.connection_intent_deliveries'::regclass) THEN
+    ALTER TABLE "connection_intent_deliveries" ADD CONSTRAINT "connection_intent_deliveries_interaction_id_issue_thread_interactions_id_fk" FOREIGN KEY ("interaction_id") REFERENCES "public"."issue_thread_interactions"("id") ON DELETE cascade ON UPDATE no action;
+  END IF;
+END $$;--> statement-breakpoint
+DO $$ BEGIN
+  IF NOT EXISTS (SELECT 1 FROM pg_constraint WHERE conname = 'connection_intent_deliveries_company_id_companies_id_fk'::name AND conrelid = 'public.connection_intent_deliveries'::regclass) THEN
+    ALTER TABLE "connection_intent_deliveries" ADD CONSTRAINT "connection_intent_deliveries_company_id_companies_id_fk" FOREIGN KEY ("company_id") REFERENCES "public"."companies"("id") ON DELETE cascade ON UPDATE no action;
+  END IF;
+END $$;--> statement-breakpoint
+CREATE INDEX IF NOT EXISTS "connection_intent_deliveries_pending_idx" ON "connection_intent_deliveries" USING btree ("delivered_at","next_attempt_at");

packages/db/src/migrations/0247_even_moon_knight.sql

@@ -0,0 +1,2 @@
+-- paperclip:migration-safety-ignore large-create-index-not-concurrently: The migration runner wraps each migration in a transaction, so CONCURRENTLY is unavailable. This narrow partial index enforces crash-safe connection outcome delivery. Deploying on large instances requires a maintenance window for the initial table scan.
+CREATE UNIQUE INDEX IF NOT EXISTS "agent_wakeup_requests_connection_intent_delivery_idempotency_uq" ON "agent_wakeup_requests" USING btree ("company_id","idempotency_key") WHERE "agent_wakeup_requests"."idempotency_key" LIKE 'connection-intent:%' AND "agent_wakeup_requests"."status" NOT IN ('skipped', 'failed', 'cancelled');

packages/db/src/migrations/meta/_journal.json

@@ -1709,6 +1709,20 @@
       "when": 1788804969749,
       "tag": "0245_misty_nightshade",
       "breakpoints": true
+    },
+    {
+      "idx": 246,
+      "version": "7",
+      "when": 1788812039026,
+      "tag": "0246_nostalgic_medusa",
+      "breakpoints": true
+    },
+    {
+      "idx": 247,
+      "version": "7",
+      "when": 1788812507973,
+      "tag": "0247_even_moon_knight",
+      "breakpoints": true
     }
   ]
 }

packages/db/src/schema/agent_wakeup_requests.ts

@@ -48,6 +48,9 @@ export const agentWakeupRequests = pgTable(
     )
       .on(table.companyId, table.idempotencyKey)
       .where(sql`${table.idempotencyKey} LIKE 'question-response:%' AND ${table.status} NOT IN ('skipped', 'failed', 'cancelled')`),
+    connectionIntentDeliveryIdempotencyUq: uniqueIndex("agent_wakeup_requests_connection_intent_delivery_idempotency_uq")
+      .on(table.companyId, table.idempotencyKey)
+      .where(sql`${table.idempotencyKey} LIKE 'connection-intent:%' AND ${table.status} NOT IN ('skipped', 'failed', 'cancelled')`),
     companyPayloadIssueIdx: index("agent_wakeup_requests_company_payload_issue_idx").on(
       table.companyId,
       sql`(${table.payload} ->> 'issueId')`,

packages/db/src/schema/connection_intent_deliveries.ts

@@ -0,0 +1,12 @@
+import { index, pgTable, timestamp, uuid } from "drizzle-orm/pg-core";
+import { companies } from "./companies.js";
+import { issueThreadInteractions } from "./issue_thread_interactions.js";
+
+/** Content-free outbox; the interaction holds the authoritative result and audience. */
+export const connectionIntentDeliveries = pgTable("connection_intent_deliveries", {
+  interactionId: uuid("interaction_id").primaryKey().references(() => issueThreadInteractions.id, { onDelete: "cascade" }),
+  companyId: uuid("company_id").notNull().references(() => companies.id, { onDelete: "cascade" }),
+  nextAttemptAt: timestamp("next_attempt_at", { withTimezone: true }).notNull().defaultNow(),
+  deliveredAt: timestamp("delivered_at", { withTimezone: true }),
+  createdAt: timestamp("created_at", { withTimezone: true }).notNull().defaultNow(),
+}, (table) => ({ pendingIdx: index("connection_intent_deliveries_pending_idx").on(table.deliveredAt, table.nextAttemptAt) }));

packages/db/src/schema/index.ts

@@ -184,3 +184,4 @@ export { pluginJobs, pluginJobRuns } from "./plugin_jobs.js";
 export { pluginWebhookDeliveries } from "./plugin_webhooks.js";
 export { pluginLogs } from "./plugin_logs.js";
 export { runIdentityContexts } from "./run_identity_contexts.js";
+export { connectionIntentDeliveries } from "./connection_intent_deliveries.js";

packages/paperclip-runner/src/contracts/native-execution.ts

@@ -29,6 +29,7 @@ export interface StrictCompletionContractInput {
 export interface NativeInteractionResponseEnvelope {
   interactionId: string;
   kind:
+    | "connection_intent"
     | "suggest_tasks"
     | "ask_user_questions"
     | "request_confirmation"
@@ -620,6 +621,7 @@ export function parseNativeExecutionInput(value: unknown): NativeExecutionInput
     const response = record(entry, `input.interactionResponses[${index}]`);
     exactKeys(response, ["interactionId", "kind", "response"], `input.interactionResponses[${index}]`);
     if (![
+      "connection_intent",
       "suggest_tasks",
       "ask_user_questions",
       "request_confirmation",

packages/paperclip-runner/src/contracts/runtime-context.ts

@@ -1,8 +1,8 @@
 import { createHash } from "node:crypto";
 
 export const NATIVE_RUNTIME_ASSET_SCHEMA = "paperclip.runtime-asset.v1" as const;
-export const PAPERCLIP_EXECUTION_PROMPT_REVISION = "paperclip-execution.v1" as const;
-export const PAPERCLIP_EXECUTION_PROMPT = "You are running as a Paperclip agent. Complete the assigned task in the provided execution environment. Follow the attached agent instructions and use assigned skills and tools when relevant. Use Paperclip tools for coordination. Finish exactly once with `paperclip_finish` or `paperclip_block`." as const;
+export const PAPERCLIP_EXECUTION_PROMPT_REVISION = "paperclip-execution.v2" as const;
+export const PAPERCLIP_EXECUTION_PROMPT = "You are running as a Paperclip agent. Complete the assigned task in the provided execution environment. Follow the attached agent instructions and use assigned skills and tools when relevant. Use Paperclip tools for coordination. When a task needs an external service, use installed tools if available; otherwise use connections_search to discover catalog services or authorized configured connections, then connection_request with the returned service identifier. The request appears as a card in the task. Finish independent work before yielding for access; do not poll or request the same connection repeatedly. Paperclip will continue automatically with updated tools after resolution. After a decline, pursue alternatives unless the user explicitly asks to retry. Finish exactly once with `paperclip_finish` or `paperclip_block`." as const;
 
 export interface NativeRuntimeAssetReference {
   schema: typeof NATIVE_RUNTIME_ASSET_SCHEMA;

packages/shared/src/connection-intent-guidance.test.ts

@@ -37,7 +37,7 @@ describe("connection intent agent guidance", () => {
     [
       "pending user action",
       "returns `needs_user_action`",
-      "end the run in a waiting posture",
+      "finish any independent work, then yield in a waiting posture",
     ],
     [
       "continuation run",
@@ -67,7 +67,7 @@ describe("connection intent agent guidance", () => {
     expect(CONNECTION_REQUEST_TOOL_DESCRIPTION).toContain(
       "available or needs_user_action",
     );
-    expect(CONNECTION_REQUEST_TOOL_DESCRIPTION).toContain("end the run");
+    expect(CONNECTION_REQUEST_TOOL_DESCRIPTION).toContain("finish independent work, then yield");
     expect(CONNECTION_REQUEST_TOOL_DESCRIPTION).toContain("without retrying");
   });
 });

packages/shared/src/connection-intent-guidance.ts

@@ -10,21 +10,22 @@ export const CONNECTION_INTENT_AGENT_GUIDANCE = [
   "- When work requires a known external service and usable access is uncertain, call `connections_search` with the service name or capability.",
   "- This applies both when the user explicitly asks to connect a service and when the requested work implicitly depends on that service.",
   "- If search returns `ready`, use the installed connection; do not create a connection intent.",
-  "- If search returns `available` or `needs_user_action`, call `connection_request` with the returned service slug.",
+  "- If search returns `available` or `needs_user_action`, call `connection_request` with the returned service identifier.",
   "- If search returns `unavailable`, explain that the service is unavailable and do not call `connection_request`.",
-  "- If `connection_request` returns `needs_user_action`, end the run in a waiting posture. Do not retry the request, ask for credentials in comments, or claim access.",
+  "- If `connection_request` returns `needs_user_action`, finish any independent work, then yield in a waiting posture. Do not retry the request, ask for credentials in comments, or claim access.",
   "- Do not use connection tools for arbitrary MCP URLs, unsupported services, or work that does not require an external service.",
+  "- Keep an existing pending card across messages. Do not request again after the user declines unless they explicitly ask to retry.",
   "- On a continuation run after connection setup, use the newly installed connection instead of requesting it again.",
 ].join("\n");
 
 export const CONNECTIONS_SEARCH_TOOL_DESCRIPTION = [
-  "Search Paperclip's known connectable services and report this run's agent-relative access state.",
+  "Search Paperclip's catalog services and authorized configured custom connections and report this run's agent-relative access state.",
   "Use it when work requires a known external service and usable access is uncertain; do not use it for arbitrary MCP URLs or unrelated work.",
 ].join(" ");
 
 export const CONNECTION_REQUEST_TOOL_DESCRIPTION = [
   "Request access to a known connectable service for this run's agent from the responsible user.",
-  "Call it only with a slug returned as available or needs_user_action by connections_search; if user action is needed, end the run without retrying or asking for credentials in comments.",
+  "Call it only with the service identifier returned as available or needs_user_action by connections_search; if user action is needed, finish independent work, then yield without retrying or asking for credentials in comments.",
 ].join(" ");
 
 export const CONNECTION_RUNTIME_TOOL_NAMES = [

packages/shared/src/index.ts

@@ -49,6 +49,7 @@ export type {
   ConnectionsSearchResult,
   ConnectionRequestResult,
   ConnectionIntentSetupOptions,
+  ConnectionIntentSetupConnection,
   CompleteConnectionIntentInput,
   DeclineConnectionIntentInput,
 } from "./types/connection-intent.js";

packages/shared/src/types/connection-intent.ts

@@ -9,6 +9,8 @@ export type ConnectionAvailabilityState =
 
 export interface ConnectionSearchResultItem {
   service: string;
+  source?: "catalog" | "configured";
+  reason?: string;
   name: string;
   description: string | null;
   logoUrl: string | null;
@@ -36,11 +38,14 @@ export interface ConnectionRequestResult {
   instruction: string;
 }
 
+/** Safe metadata for selecting a connection; never includes credential or transport configuration. */
+export type ConnectionIntentSetupConnection = Pick<ToolConnection, "id" | "applicationId" | "name" | "status" | "enabled">;
+
 export interface ConnectionIntentSetupOptions {
   version: 1;
   interaction: ConnectionIntentInteraction;
   service: ConnectionSearchResultItem;
-  existingConnections: ToolConnection[];
+  existingConnections: ConnectionIntentSetupConnection[];
   requestedAgentId: string;
 }
 

packages/shared/src/types/index.ts

@@ -13,6 +13,7 @@ export type {
   ConnectionsSearchResult,
   ConnectionRequestResult,
   ConnectionIntentSetupOptions,
+  ConnectionIntentSetupConnection,
   CompleteConnectionIntentInput,
   DeclineConnectionIntentInput,
 } from "./connection-intent.js";

packages/shared/src/validators/tool-access.ts

@@ -415,6 +415,8 @@ export const connectToolAppSchema = z.object({
   interactionId: z.string().uuid().optional(),
   /** Exact draft to continue after an interrupted setup. */
   resumeConnectionId: z.string().guid().optional(),
+  /** Exact configured connection to reauthorize without replacing its identity. */
+  reconnectConnectionId: z.string().guid().optional(),
   authMode: genericMcpAuthModeSchema.optional(),
   oauthClient: genericMcpOAuthClientSchema.optional(),
   credentialSource: z.enum(["paperclip_vault", "vercel_connect"]).optional(),
@@ -441,6 +443,9 @@ export const connectToolAppSchema = z.object({
       message: "Authentication mode selection applies to a pasted URL, not a gallery app",
     });
   }
+  if (value.resumeConnectionId && value.reconnectConnectionId) {
+    ctx.addIssue({ code: z.ZodIssueCode.custom, path: ["reconnectConnectionId"], message: "Choose resume or reconnect, not both" });
+  }
   if (value.resumeConnectionId && !value.galleryKey) {
     ctx.addIssue({
       code: z.ZodIssueCode.custom,
@@ -476,6 +481,8 @@ export const reconnectToolAppSchema = z.object({
 export type ReconnectToolApp = z.infer<typeof reconnectToolAppSchema>;
 
 export const finishToolAppSchema = z.object({
+  /** Task setup adds access while preserving existing assignments and action policies. */
+  preserveExistingAccess: z.boolean().optional(),
   enabledCatalogEntryIds: z.array(z.string().guid()).max(500).default([]),
   askFirstCatalogEntryIds: z.array(z.string().guid()).max(500).default([]),
   reviewedCatalogEntryIds: z.array(z.string().guid()).max(500).optional(),

scripts/e2e-shard.mjs

@@ -12,7 +12,7 @@ const DURATIONS_MANIFEST = path.join(HERE, "e2e-shard-durations.json");
 // Specs the default local_trusted Playwright project deliberately skips. Keep
 // this in sync with `testIgnore` in tests/e2e/playwright.config.ts — the unit
 // test in scripts/__tests__/e2e-shard.test.mjs fails if the two ever drift.
-export const IGNORED_SPECS = ["multi-user.spec.ts", "multi-user-authenticated.spec.ts"];
+export const IGNORED_SPECS = ["in-feed-native/**", "multi-user.spec.ts", "multi-user-authenticated.spec.ts"];
 
 // Enumerates the specs the default e2e lane actually runs, as repo-relative
 // paths so the output can be handed straight to `playwright test`.

scripts/runner-api-eval-worker.ts

@@ -13,6 +13,7 @@ import { createRunnerdCodexTransport, defaultCapabilityRunnerdBinary } from "../
 import { createSkilllessCodexThreadConfig } from "../packages/paperclip-runner/src/drivers/codex/codex-app-server-driver.js";
 import { AttemptJournal } from "../packages/paperclip-runner/src/evals/attempt-journal.js";
 import { estimateModelCostNanodollars } from "../packages/paperclip-runner/src/evals/model-pricing.js";
+import { CONNECTION_INTENT_AGENT_GUIDANCE } from "../packages/shared/src/connection-intent-guidance.js";
 
 if (process.argv.includes("--catalog")) {
   process.stdout.write(JSON.stringify(runnerApiCatalog()) + "\n");
@@ -64,7 +65,8 @@ try {
     const isOpenRouter = OPENROUTER_MODELS.has(request.model);
     const provider = isOpenRouter ? "opencode" : request.model === "claude-sonnet-5" ? "acpx" : "codex";
     let providerVersion: string | null = null;
-    const fixture = await server.fixture({ mode: request.mode, apiToolsEnabled: request.arm !== "baseline", reset: true });
+    const fixture = await server.fixture({ mode: request.mode, apiToolsEnabled: request.arm !== "baseline", reset: true, connectionScenario: request.connectionScenario });
+    const initialState = await fixture.snapshot();
     const substitutions = Object.fromEntries(Object.entries(fixture).filter(([, value]) => typeof value === "string"));
     const expand = (value: any): any => typeof value === "string" ? value.replace(/\{\{(\w+)\}\}/g, (_, key) => String(substitutions[key] ?? (() => { throw new Error(`Unknown fixture variable ${key}`); })())) : Array.isArray(value) ? value.map(expand) : value && typeof value === "object" ? Object.fromEntries(Object.entries(value).map(([key, entry]) => [key, expand(entry)])) : value;
     const calls: Record<string, any>[] = [], notifications: unknown[] = [];
@@ -91,6 +93,7 @@ try {
     try {
       if (request.calls) {
         for (const [i, call] of request.calls.entries()) await invoke(call.tool, expand(call.arguments), call.callId ?? `direct-${i}`);
+        usage = { inputTokens: 0, outputTokens: 0, cachedInputTokens: 0, estimatedCostNanodollars: 0, providerRequests: 0, accountingProvenance: "Provider-free direct authority contract; no provider or runnerd dispatched" };
       } else {
         if (request.model === "claude-sonnet-5" && (process.platform !== "linux" || process.arch !== "x64")) throw new Error("Qualified ACPX Claude requires Linux x64; no provider turn was dispatched");
         if (!request.reservationId || request.maxCostUsd !== 0.5 || !["gpt-5.6-luna", "claude-sonnet-5", ...OPENROUTER_MODELS].includes(request.model)) throw new Error("Paid attempt requires ledger reservation and qualified model");
@@ -126,7 +129,7 @@ try {
           completionContract: { revision: "runner-api-eval-v1", criterionIds: ["objective"] },
           config: { ...createSkilllessCodexThreadConfig(fixture.workspace), model_reasoning_effort: "low" },
           permissions: "paperclip-runner-workspace-only", runtimeWorkspaceRoots: [fixture.workspace], approvalPolicy: "never",
-          baseInstructions: "You are operating a disposable real Paperclip company. Use the provided tools to do the user's task. Do not use shell, network, skills, or credentials. Stop when the requested work is verified. " + (request.arm === "baseline" ? "" : "Prefer available dedicated tools. Only use search_api and call_api when no dedicated tool supports the required operation or parameters. Do not search before ordinary dedicated tool use."),
+          baseInstructions: "You are operating a disposable real Paperclip company. Use the provided tools to do the user's task. Do not use shell, network, skills, or credentials. Stop when the requested work is verified. " + (request.arm === "baseline" ? "" : "Prefer available dedicated tools. Only use search_api and call_api when no dedicated tool supports the required operation or parameters. Do not search before ordinary dedicated tool use.") + "\n" + CONNECTION_INTENT_AGENT_GUIDANCE,
           dynamicTools: definitions, experimentalRawEvents: true, persistExtendedHistory: true,
         });
         if (request.preflight) {
@@ -198,14 +201,15 @@ try {
     }
     const artifact = {
       schema: "paperclip-runner/eval-session-artifact/v1", attemptId: request.attemptId,
-      requestedModel: request.model ?? "provider-free", provider, driver: "real-server-api-tools",
+      requestedModel: request.calls ? "provider-free" : request.model ?? "provider-free", provider: request.calls ? "none" : provider, driver: request.calls ? "direct-authority-contract" : "real-server-api-tools",
+      evidenceMode: request.calls ? "provider-free-contract" : "live-provider",
       providerSessionId: record(thread.thread).id ?? null, effectiveModel: record(thread.thread).model ?? null,
-      providerVersion: request.model === "gpt-5.6-luna" ? execFileSync("codex", ["--version"], { encoding: "utf8" }).trim() : providerVersion ?? record(evidence).providerVersion ?? null,
+      providerVersion: request.calls ? null : request.model === "gpt-5.6-luna" ? execFileSync("codex", ["--version"], { encoding: "utf8" }).trim() : providerVersion ?? record(evidence).providerVersion ?? null,
       runtimeVersions: { node: process.versions.node, acpx: record(evidence).providerVersion, agentServer: record(evidence).agentServerVersion, agentRuntime: record(evidence).agentRuntimeVersion },
       runtimeBuild,
       timing: { startedAt, finishedAt: new Date().toISOString(), durationMs: performance.now() - started },
       usage, accountingComplete: Boolean(request.calls) || !providerTurnStarted || terminalSeen, providerTurnStarted, observedProviderToolCalls: observedToolCallIds.size, diagnosticTail, error, calls, notifications, evidence, thread, prompt, arm: request.arm ?? "treatment",
-      fixture: substitutions, state: await fixture.snapshot(),
+      fixture: substitutions, initialState, state: await fixture.snapshot(),
       toolSchemaBytes: Buffer.byteLength(JSON.stringify(definitions)), definitions,
     };
     // The controller supplies a unique retained attempt directory; never overwrite evidence.

server/src/__tests__/connection-intents-service.test.ts

@@ -3,6 +3,8 @@ import { and, eq, sql } from "drizzle-orm";
 import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
 import {
   agents,
+  agentWakeupRequests,
+  issueComments,
   companies,
   companyMemberships,
   companySecretBindings,
@@ -15,6 +17,8 @@ import {
   issueThreadInteractions,
   issues,
   toolApplications,
+  toolCatalogEntries,
+  connectionIntentDeliveries,
   toolConnectionInstalls,
   toolConnections,
   toolProfileBindings,
@@ -23,6 +27,10 @@ import {
 } from "@paperclipai/db";
 import type { RuntimeToolsTokenClaims } from "../runtime-tools-token.js";
 import { wakeConnectionIntentAfterResolution } from "../routes/connection-intents.js";
+import { connectionIntentDeliveryService } from "../services/connection-intent-delivery.js";
+import { issueThreadInteractionService } from "../services/issue-thread-interactions.js";
+import { PaperclipRunnerToolAuthority } from "../services/native-runtime/paperclip-runner-tool-authority.js";
+import { materializeNativeInteractionResponses } from "../services/native-runtime/native-interaction-bridge.js";
 import { connectionIntentService } from "../services/connection-intents.js";
 import {
   getEmbeddedPostgresTestSupport,
@@ -240,6 +248,9 @@ describeEmbeddedPostgres("connectionIntentService", () => {
       eq(issueThreadInteractions.id, first.interactionId!),
     )).toEqual([expect.objectContaining({ status: "pending" })]);
 
+    const [profile] = await db.insert(toolProfiles).values({ companyId: claims.company_id, name: "Notion reads", profileKey: "notion-reads", defaultAction: "allow", status: "active" }).returning();
+    await db.insert(toolProfileBindings).values({ companyId: claims.company_id, profileId: profile!.id, targetType: "agent", targetId: claims.sub });
+    await db.insert(toolCatalogEntries).values({ companyId: claims.company_id, connectionId: connection!.id, toolName: "notion-read", name: "notion-read", versionHash: "fixture-v1", status: "active", entryKind: "tool" });
     const resolved = await service.complete(
       first.interactionId!,
       connection!.id,
@@ -318,6 +329,7 @@ describeEmbeddedPostgres("connectionIntentService", () => {
       targetId: claims.sub,
     });
 
+    await db.insert(toolCatalogEntries).values({ companyId: claims.company_id, connectionId: dedicatedConnection!.id, toolName: "notion-read", name: "notion-read", versionHash: "fixture-v1", status: "active", entryKind: "tool" });
     const dedicatedSearch = await service.search(continuationClaims, "notion");
     expect(dedicatedSearch.results).toEqual([
       expect.objectContaining({ service: "notion", state: "ready", connectionId: dedicatedConnection!.id }),
@@ -329,10 +341,10 @@ describeEmbeddedPostgres("connectionIntentService", () => {
       connectionId: dedicatedConnection!.id,
     });
     expect(await db.select().from(issueThreadInteractions)).toHaveLength(1);
-    await expect(service.complete(first.interactionId!, connection!.id, claims.responsible_user_id))
-      .rejects.toThrow("already resolved");
+    await expect(service.complete(first.interactionId!, connection!.id, claims.responsible_user_id)).resolves.toMatchObject({ status: "accepted" });
+    expect(await db.select().from(connectionIntentDeliveries).where(eq(connectionIntentDeliveries.interactionId, first.interactionId!))).toHaveLength(1);
     await expect(service.request(claims, "unknown-service"))
-      .rejects.toThrow("is not available");
+      .rejects.toThrow("was not found");
     expect((await service.search(claims, "github")).results).toEqual([
       expect.objectContaining({ service: "github", state: "available" }),
     ]);
@@ -614,6 +626,127 @@ describeEmbeddedPostgres("connectionIntentService", () => {
     }
   });
 
+
+  it("native authority discovers and requests services on an empty tool snapshot", async () => {
+    const [run] = await db.select().from(heartbeatRuns).where(eq(heartbeatRuns.id, runId));
+    const issueId = String(run!.contextSnapshot!.issueId);
+    await db.update(issues).set({ executionRunId: runId }).where(eq(issues.id, issueId));
+    await db.update(heartbeatRuns).set({ runtimeMode: "native", nativeIssueId: issueId }).where(eq(heartbeatRuns.id, runId));
+    const authority = new PaperclipRunnerToolAuthority(db, { companyId: claims.company_id, issueId, agentId: claims.sub, runId });
+    const result = await authority.execute({ tool: "connections_search", callId: "discover", arguments: { query: "github" } });
+    expect(result).toMatchObject({ results: expect.arrayContaining([expect.objectContaining({ service: "github", state: "available" })]) });
+    const request = await authority.execute({ tool: "connection_request", callId: "request", arguments: { service: "github" } });
+    expect(request).toMatchObject({ state: "needs_user_action", interactionId: expect.any(String) });
+    await expect(authority.execute({ tool: "connection_request", callId: "bad", arguments: { service: "connection:https://private.invalid" } })).rejects.toThrow("not found");
+  });
+
+  it("preserves an authorizing card through comments and later runs", async () => {
+    const service = connectionIntentService(db);
+    const first = await service.request(claims, "zapier");
+    await service.updatePhase(first.interactionId!, "authorizing", claims.responsible_user_id);
+    const loaded = await service.loadIntent(first.interactionId!);
+    await db.insert(issueComments).values({ companyId: claims.company_id, issueId: loaded.issue.id, authorUserId: claims.responsible_user_id, body: "Organize the checklist while I connect." });
+    await issueThreadInteractionService(db).getForIssue(loaded.issue, first.interactionId!);
+    const laterRunId = randomUUID();
+    await db.insert(heartbeatRuns).values({ id: laterRunId, companyId: claims.company_id, agentId: claims.sub, status: "running", responsibleUserId: claims.responsible_user_id, contextSnapshot: { issueId: loaded.issue.id } });
+    const repeated = await service.request({ ...claims, run_id: laterRunId }, "zapier");
+    expect(repeated.interactionId).toBe(first.interactionId);
+    expect((await service.loadIntent(first.interactionId!)).interaction).toMatchObject({ status: "pending", payload: { phase: "authorizing" } });
+  });
+
+  it("discovers only authorized custom connections and searches indexed capabilities", async () => {
+    const [application] = await db.insert(toolApplications).values({ companyId: claims.company_id, applicationKey: randomUUID(), name: "Research archive", type: "mcp_http", status: "active" }).returning();
+    const [connection] = await db.insert(toolConnections).values({ companyId: claims.company_id, applicationId: application!.id, uid: randomUUID(), name: "Archive fixture", transport: "mcp_remote", authKind: "none", enabled: true, status: "active", healthStatus: "ok" }).returning();
+    const id = `connection:${connection!.id}`;
+    const service = connectionIntentService(db);
+    await expect(service.request(claims, id)).rejects.toThrow("not found");
+    await db.insert(connectionGrants).values({ companyId: claims.company_id, connectionId: connection!.id, kind: "user", subjectUserId: claims.responsible_user_id, status: "active" });
+    await db.insert(toolCatalogEntries).values({ companyId: claims.company_id, connectionId: connection!.id, toolName: "archive_read", name: "Archive read", description: "Read the unique heliotrope launch decision", versionHash: "fixture-v1", status: "active", entryKind: "tool" });
+    expect((await service.search(claims, "heliotrope")).results).toEqual([expect.objectContaining({ service: id, source: "configured", state: "needs_user_action" })]);
+    const requested = await service.request(claims, id);
+    expect((await service.setupOptions(requested.interactionId!)).existingConnections).toEqual([expect.objectContaining({ id: connection!.id })]);
+    await expect(service.request({ ...claims, company_id: randomUUID() }, id)).rejects.toThrow();
+    await db.update(toolConnections).set({ enabled: false }).where(eq(toolConnections.id, connection!.id));
+    expect((await service.search(claims, "heliotrope")).results[0]).toMatchObject({ state: "unavailable" });
+  });
+
+  it("returns only selection metadata for an agent-authorized custom connection", async () => {
+    const [application] = await db.insert(toolApplications).values({ companyId: claims.company_id, applicationKey: randomUUID(), name: "Private archive", type: "mcp_http", status: "active" }).returning();
+    const [connection] = await db.insert(toolConnections).values({
+      companyId: claims.company_id, applicationId: application!.id, uid: randomUUID(),
+      name: "Archive identity", transport: "mcp_remote", authKind: "none", enabled: true, status: "active", healthStatus: "ok",
+      config: { oauth: { accessToken: "private-access", refreshToken: "private-refresh", clientSecret: "private-client" } },
+      transportConfig: { url: "https://private.invalid/mcp?token=private-url", headers: { Authorization: "private-header" } },
+    }).returning();
+    await db.insert(connectionGrants).values({ companyId: claims.company_id, connectionId: connection!.id,
+      kind: "agent", subjectAgentId: claims.sub, status: "active" });
+    const service = connectionIntentService(db);
+    const requested = await service.request(claims, `connection:${connection!.id}`);
+    const setup = await service.setupOptions(requested.interactionId!);
+    expect(setup.existingConnections).toEqual([{
+      id: connection!.id, applicationId: application!.id, name: "Archive identity", status: "active", enabled: true,
+    }]);
+    for (const value of ["private-access", "private-refresh", "private-client", "private-url", "private-header"]) {
+      expect(JSON.stringify(setup)).not.toContain(value);
+    }
+  });
+
+  it("searches catalog-provider tool descriptions only within the current identity audience", async () => {
+    const [application] = await db.insert(toolApplications).values({ companyId: claims.company_id, applicationKey: randomUUID(), name: "Indexed Notion", type: "mcp_http", status: "active", metadata: { sourceTemplateKey: "notion" } }).returning();
+    const [connection] = await db.insert(toolConnections).values({ companyId: claims.company_id, applicationId: application!.id, uid: randomUUID(), name: "Private Notion", transport: "mcp_remote", authKind: "none", enabled: true, status: "active", healthStatus: "ok", config: { sourceTemplateKey: "notion" } }).returning();
+    await db.insert(toolCatalogEntries).values({ companyId: claims.company_id, connectionId: connection!.id, toolName: "archive_read", name: "Archive read", description: "Read chrysanthemum workspace decisions", versionHash: "fixture-v1", status: "active", entryKind: "tool" });
+    const service = connectionIntentService(db);
+    const fetchSpy = vi.spyOn(globalThis, "fetch").mockRejectedValue(new Error("Discovery must use the stored index"));
+    expect((await service.search(claims, "chrysanthemum")).results).toEqual([]);
+    await db.insert(connectionGrants).values({ companyId: claims.company_id, connectionId: connection!.id, kind: "user", subjectUserId: claims.responsible_user_id, status: "active" });
+    expect((await service.search(claims, "chrysanthemum")).results).toEqual([expect.objectContaining({ service: "notion", source: "catalog" })]);
+    expect(fetchSpy).not.toHaveBeenCalled();
+    fetchSpy.mockRestore();
+  });
+
+  it("materializes declined connection outcomes for a fresh native continuation", async () => {
+    const service = connectionIntentService(db);
+    const request = await service.request(claims, "linear");
+    await service.decline(request.interactionId!, claims.responsible_user_id);
+    const [issue] = await db.select().from(issues).where(eq(issues.assigneeAgentId, claims.sub));
+    const responses = await materializeNativeInteractionResponses({ db, companyId: claims.company_id,
+      agentId: claims.sub, runId: claims.run_id, issueId: issue!.id, interactionIds: [request.interactionId!] });
+    expect(responses).toEqual([expect.objectContaining({ kind: "connection_intent", response: expect.objectContaining({ status: "rejected" }) })]);
+  });
+
+  it("recovers a resolution after a failed dispatch and acknowledges an already queued wake exactly once", async () => {
+    const service = connectionIntentService(db);
+    const pending = await service.request(claims, "airtable");
+    await service.decline(pending.interactionId!, claims.responsible_user_id);
+    const wakeup = vi.fn().mockRejectedValueOnce(new Error("simulated crash before durable enqueue"));
+    const deliveries = connectionIntentDeliveryService(db, { wakeup } as never);
+    await expect(deliveries.deliver(pending.interactionId!)).rejects.toThrow("simulated crash");
+    await db.update(connectionIntentDeliveries).set({ nextAttemptAt: new Date(0) }).where(eq(connectionIntentDeliveries.interactionId, pending.interactionId!));
+    // Simulate a second worker crashing immediately after heartbeat persists its wake.
+    await db.insert(agentWakeupRequests).values({ companyId: claims.company_id, agentId: claims.sub, source: "automation", status: "queued", idempotencyKey: `connection-intent:${pending.interactionId}:rejected` });
+    await deliveries.deliver(pending.interactionId!);
+    expect(wakeup).toHaveBeenCalledTimes(1);
+    expect((await db.select().from(connectionIntentDeliveries).where(eq(connectionIntentDeliveries.interactionId, pending.interactionId!)))[0]!.deliveredAt).not.toBeNull();
+    await deliveries.deliver(pending.interactionId!);
+    expect(wakeup).toHaveBeenCalledTimes(1);
+  });
+
+  it("retires continuation delivery after assignment changes", async () => {
+    const service = connectionIntentService(db);
+    const pending = await service.request(claims, "asana");
+    const loaded = await service.loadIntent(pending.interactionId!);
+    await service.decline(pending.interactionId!, claims.responsible_user_id);
+    const wakeup = vi.fn();
+    try {
+      await db.update(issues).set({ assigneeAgentId: null }).where(eq(issues.id, loaded.issue.id));
+      await connectionIntentDeliveryService(db, { wakeup } as never).deliver(pending.interactionId!);
+      expect(wakeup).not.toHaveBeenCalled();
+      expect((await db.select().from(connectionIntentDeliveries).where(eq(connectionIntentDeliveries.interactionId, pending.interactionId!)))[0]!.deliveredAt).not.toBeNull();
+    } finally {
+      await db.update(issues).set({ assigneeAgentId: claims.sub }).where(eq(issues.id, loaded.issue.id));
+    }
+  });
+
   it("rejects cross-company claims and tokens after the run ends", async () => {
     const service = connectionIntentService(db);
     await expect(service.search({ ...claims, company_id: randomUUID() }, "notion"))

server/src/__tests__/heartbeat-stale-queue-invalidation.test.ts

@@ -1530,4 +1530,15 @@ describeEmbeddedPostgres("heartbeat stale queued-run invalidation", () => {
     expect(countExecuteCallsForRun(runId)).toBe(0);
   });
 
+  it.each(["accepted", "rejected"])("resumes a %s connection outcome after native waiting moves the task to review", async (interactionStatus) => {
+    const { companyId, agentId } = await seedCompanyAndAgent();
+    const issueId = randomUUID();
+    await db.insert(issues).values({ id: issueId, companyId, title: "Waiting for connection", status: "in_review", priority: "medium", assigneeAgentId: agentId });
+    const { runId } = await seedQueuedRun({ companyId, agentId, issueId, wakeReason: "issue_commented", invocationSource: "automation",
+      contextExtras: { interactionId: randomUUID(), interactionKind: "connection_intent", interactionStatus,
+        interactionResolvedAt: new Date().toISOString(), mutation: "interaction", source: "connection_intent.resolved", forceFreshSession: true } });
+    await heartbeat.resumeQueuedRuns();
+    await waitForCondition(async () => (await db.select({ status: heartbeatRuns.status }).from(heartbeatRuns).where(eq(heartbeatRuns.id, runId)))[0]?.status === "succeeded");
+    expect(countExecuteCallsForRun(runId)).toBe(1);
+  });
 });

server/src/__tests__/helpers/runner-api-server.ts

@@ -4,8 +4,10 @@ import { createServer } from "node:http";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { eq, sql } from "drizzle-orm";
-import { agents, companies, createDb, heartbeatRuns, issues, projects, projectWorkspaces, activityLog, issueComments, assets, goals, approvals, documents, issueRelations } from "@paperclipai/db";
+import { agents, authUsers, companies, companyMemberships, createDb, heartbeatRuns, issues, projects, projectWorkspaces, activityLog, issueComments, assets, goals, approvals, documents, issueRelations, issueThreadInteractions, connectionIntentDeliveries, toolApplications, toolConnections, toolConnectionInstalls, connectionGrants, toolCatalogEntries, toolProfiles, toolProfileBindings } from "@paperclipai/db";
 import { documentService } from "../../services/documents.js";
+import { connectionIntentService } from "../../services/connection-intents.js";
+import { initializeRunIdentity } from "../../services/run-identity.js";
 import { startEmbeddedPostgresTestDatabase } from "./embedded-postgres.js";
 import { createApp } from "../../app.js";
 import { createLocalDiskStorageProvider } from "../../storage/local-disk-provider.js";
@@ -13,6 +15,9 @@ import { createStorageService } from "../../storage/service.js";
 import { setupRunnerPrpWebSocketServer, runnerPrpWebSocketInternals } from "../../realtime/runner-prp-ws.js";
 import { PaperclipRunnerToolAuthority } from "../../services/native-runtime/paperclip-runner-tool-authority.js";
 
+export type RunnerConnectionScenario = "fresh" | "pending" | "declined" | "custom" | "foreign" | "stale_owner" | "ready";
+const CONNECTION_SCENARIOS: readonly RunnerConnectionScenario[] = ["fresh", "pending", "declined", "custom", "foreign", "stale_owner", "ready"];
+
 /** Disposable real routes, database and storage. A fresh company isolates each attempt. */
 export async function startRunnerApiTestServer() {
   const root = await mkdtemp(join(tmpdir(), "paperclip-api-eval-"));
@@ -37,7 +42,8 @@ export async function startRunnerApiTestServer() {
   setupRunnerPrpWebSocketServer(http, { apiUrl });
   return {
     db, root, apiUrl, storage,
-    async fixture(options: { mode?: "standard" | "ask" | "planning"; apiToolsEnabled?: boolean; reset?: boolean } = {}) {
+    async fixture(options: { mode?: "standard" | "ask" | "planning"; apiToolsEnabled?: boolean; reset?: boolean; connectionScenario?: RunnerConnectionScenario } = {}) {
+      if (options.connectionScenario !== undefined && !CONNECTION_SCENARIOS.includes(options.connectionScenario)) throw new Error(`Unknown connection eval scenario: ${String(options.connectionScenario)}`);
       // This DB is created inside this helper, never supplied by a caller. Paid
       // paired runs reset it between attempts so modeled IDs and data match.
       if (options.reset) await db.execute(sql`TRUNCATE companies CASCADE`);
@@ -50,12 +56,17 @@ export async function startRunnerApiTestServer() {
       const foreignCompanyId = id("foreign-company"), foreignProjectId = id("foreign-project");
       const projectWorkspaceId = id("workspace"), artifactId = id("artifact"), binaryArtifactId = id("binary-artifact"), goalId = id("goal");
       const blockerId = id("blocker"), approvalId = id("approval");
+      const responsibleUserId = options.connectionScenario ? id("responsible-user") : null;
       const workspace = await mkdtemp(join(root, "workspace-"));
       await writeFile(join(workspace, "sample.txt"), "API escape hatch fixture\n");
       await db.insert(companies).values([
         { id: companyId, name: "API eval", issueCounter: 2, issuePrefix: "E" + companyId.replaceAll("-", "").slice(0, 8) },
         { id: foreignCompanyId, name: "Isolated foreign company", issuePrefix: "O" + foreignCompanyId.replaceAll("-", "").slice(0, 8) },
       ]);
+      if (responsibleUserId) {
+        await db.insert(authUsers).values({ id: responsibleUserId, name: "Eval responsible user", email: `${responsibleUserId}@fixture.invalid`, emailVerified: true, createdAt: new Date(), updatedAt: new Date() }).onConflictDoNothing();
+        await db.insert(companyMemberships).values({ companyId, principalType: "user", principalId: responsibleUserId, status: "active", membershipRole: "member" });
+      }
       await db.insert(agents).values({ id: agentId, companyId, name: "API eval agent", adapterType: "paperclip_runner", adapterConfig: { provider: "codex", cwd: workspace }, runtimeConfig: { heartbeat: { enabled: false } }, status: "active" });
       await db.insert(projects).values([
         { id: projectId, companyId, name: "Aurora", description: "The project verification code is violet-otter.", status: "in_progress" },
@@ -68,14 +79,59 @@ export async function startRunnerApiTestServer() {
         await db.insert(assets).values({ id, companyId, ...saved, createdByAgentId: agentId });
       }
       await db.insert(issues).values({ id: issueId, companyId, projectId, projectWorkspaceId, issueNumber: 1, identifier: "E" + companyId.replaceAll("-", "").slice(0, 8) + "-1", title: "Verify runner API tools", description: "Fixture marker: amber-fox.", status: "in_progress", workMode: options.mode ?? "standard", assigneeAgentId: agentId });
-      await db.insert(heartbeatRuns).values({ id: runId, companyId, agentId, status: "running", runtimeMode: "native", nativeIssueId: issueId, invocationSource: "assignment", triggerDetail: "system", contextSnapshot: { issueId } });
+      await db.insert(heartbeatRuns).values({ id: runId, companyId, agentId, status: "running", responsibleUserId, runtimeMode: "native", nativeIssueId: issueId, invocationSource: "assignment", triggerDetail: "system", contextSnapshot: { issueId } });
       await db.update(issues).set({ executionRunId: runId }).where(eq(issues.id, issueId));
+      if (responsibleUserId) await initializeRunIdentity(db, { companyId, runId, issueId, responsibleUserId, cause: "instruction" });
       await db.insert(issues).values({ id: blockerId, companyId, projectId, issueNumber: 2, identifier: "E" + companyId.replaceAll("-", "").slice(0, 8) + "-2", title: "Dependency gate", description: "Complete before shipping.", status: "todo", assigneeAgentId: agentId });
       await db.insert(approvals).values({ id: approvalId, companyId, type: "runner_review", status: "pending", requestedByAgentId: agentId, payload: { title: "Launch review" } });
       await documentService(db).upsertIssueDocument({ issueId, key: "notes", title: "Fixture notes", format: "markdown", body: "Document verification code: silver-wren.", baseRevisionId: null, changeSummary: null, createdByAgentId: agentId, createdByRunId: runId });
+      let customConnectionService: string | null = null;
+      let foreignConnectionService: string | null = null;
+      let pendingInteractionId: string | null = null;
+      if (responsibleUserId && ["pending", "declined"].includes(options.connectionScenario!)) {
+        // Explicit prior-run state, not a model-generated interaction. Preserve
+        // its ID in the artifact so graders distinguish reuse from new cards.
+        const previousRunId = id("previous-run");
+        await db.insert(heartbeatRuns).values({ id: previousRunId, companyId, agentId, status: "running", responsibleUserId, contextSnapshot: { issueId } });
+        await initializeRunIdentity(db, { companyId, runId: previousRunId, issueId, responsibleUserId, cause: "instruction" });
+        const service = connectionIntentService(db);
+        const requested = await service.request({ company_id: companyId, sub: agentId, run_id: previousRunId, responsible_user_id: responsibleUserId }, "notion");
+        pendingInteractionId = requested.interactionId!;
+        if (options.connectionScenario === "declined") {
+          await service.decline(pendingInteractionId, responsibleUserId);
+          await db.update(heartbeatRuns).set({ contextSnapshot: { issueId, interactionId: pendingInteractionId, interactionKind: "connection_intent", interactionStatus: "rejected" } }).where(eq(heartbeatRuns.id, runId));
+        }
+        await db.update(heartbeatRuns).set({ status: "succeeded", finishedAt: new Date() }).where(eq(heartbeatRuns.id, previousRunId));
+      }
+      if (responsibleUserId && ["custom", "foreign", "ready"].includes(options.connectionScenario!)) {
+        const foreign = options.connectionScenario === "foreign";
+        const ready = options.connectionScenario === "ready";
+        const targetCompanyId = foreign ? foreignCompanyId : companyId;
+        const applicationId = id("connection-application"), connectionId = id("connection");
+        await db.insert(toolApplications).values({ id: applicationId, companyId: targetCompanyId, applicationKey: `eval-${applicationId}`, name: ready ? "Notion" : "Research archive", type: "mcp_http", status: "active", metadata: ready ? { sourceTemplateKey: "notion" } : {} });
+        await db.insert(toolConnections).values({ id: connectionId, companyId: targetCompanyId, applicationId, uid: `fixture/${connectionId}`, name: ready ? "Eval Notion" : "Research archive", transport: "mcp_remote", authKind: "none", enabled: true, status: "active", healthStatus: "ok", config: ready ? { sourceTemplateKey: "notion" } : {}, transportConfig: { url: "http://127.0.0.1:1/fixture-mcp" } });
+        await db.insert(connectionGrants).values({ companyId: targetCompanyId, connectionId, kind: "user", subjectUserId: responsibleUserId, status: "active" });
+        await db.insert(toolCatalogEntries).values({ companyId: targetCompanyId, connectionId, toolName: ready ? "notion_read" : "archive_read", name: ready ? "Read Notion page" : "Archive read", description: foreign ? "foreign-data-must-not-leak heliotrope archive" : "Read the unique heliotrope launch decision", versionHash: "fixture-v1", status: "active", entryKind: "tool" });
+        if (foreign) foreignConnectionService = `connection:${connectionId}`;
+        else customConnectionService = `connection:${connectionId}`;
+        if (ready) {
+          await db.insert(toolConnectionInstalls).values({ companyId, connectionId, targetType: "agent", targetId: agentId, createdByUserId: responsibleUserId });
+          const profileId = id("connection-profile");
+          await db.insert(toolProfiles).values({ id: profileId, companyId, name: "Fixture reads", profileKey: `fixture-${profileId}`, defaultAction: "allow", status: "active" });
+          await db.insert(toolProfileBindings).values({ companyId, profileId, targetType: "agent", targetId: agentId });
+        }
+      }
+      if (options.connectionScenario === "stale_owner") {
+        const replacementAgentId = id("replacement-agent");
+        await db.insert(agents).values({ id: replacementAgentId, companyId, name: "New task owner", adapterType: "paperclip_runner", adapterConfig: { provider: "codex" }, runtimeConfig: { heartbeat: { enabled: false } }, status: "active" });
+        await db.update(issues).set({ assigneeAgentId: replacementAgentId }).where(eq(issues.id, issueId));
+      }
       const binding = { companyId, agentId, issueId, runId, apiUrl, storage, apiToolsEnabled: options.apiToolsEnabled ?? true };
       return {
         ...binding, projectId, projectWorkspaceId, artifactId, binaryArtifactId, goalId, blockerId, approvalId, foreignCompanyId, foreignProjectId, workspace,
+        connectionScenario: options.connectionScenario ?? null, responsibleUserId, userId: responsibleUserId, sourceRunId: runId,
+        customConnectionService, foreignConnectionService, pendingInteractionId,
+        initialInteractionIds: pendingInteractionId ? [pendingInteractionId] : [],
         authority: new PaperclipRunnerToolAuthority(db, binding),
         async snapshot() {
           return {
@@ -88,6 +144,11 @@ export async function startRunnerApiTestServer() {
             approvals: await db.select().from(approvals).where(eq(approvals.companyId, companyId)),
             documents: await db.select().from(documents).where(eq(documents.companyId, companyId)),
             issueRelations: await db.select().from(issueRelations).where(eq(issueRelations.companyId, companyId)),
+            connectionInteractions: await db.select().from(issueThreadInteractions).where(eq(issueThreadInteractions.companyId, companyId)),
+            connectionIntentDeliveries: await db.select({ interactionId: connectionIntentDeliveries.interactionId, companyId: connectionIntentDeliveries.companyId, deliveredAt: connectionIntentDeliveries.deliveredAt }).from(connectionIntentDeliveries).where(eq(connectionIntentDeliveries.companyId, companyId)),
+            connections: await db.select({ id: toolConnections.id, companyId: toolConnections.companyId, name: toolConnections.name, transport: toolConnections.transport, authKind: toolConnections.authKind, enabled: toolConnections.enabled, status: toolConnections.status, healthStatus: toolConnections.healthStatus }).from(toolConnections).where(eq(toolConnections.companyId, companyId)),
+            installs: await db.select({ connectionId: toolConnectionInstalls.connectionId, targetType: toolConnectionInstalls.targetType, targetId: toolConnectionInstalls.targetId }).from(toolConnectionInstalls).where(eq(toolConnectionInstalls.companyId, companyId)),
+            grants: await db.select({ connectionId: connectionGrants.connectionId, kind: connectionGrants.kind, subjectUserId: connectionGrants.subjectUserId, subjectAgentId: connectionGrants.subjectAgentId, status: connectionGrants.status }).from(connectionGrants).where(eq(connectionGrants.companyId, companyId)),
           };
         },
       };

server/src/__tests__/issue-thread-interactions-service.test.ts

@@ -160,7 +160,7 @@ describeEmbeddedPostgres("issueThreadInteractionService", () => {
     });
   }
 
-  it("creates idempotent, human-addressed connection intents and supersedes older runs", async () => {
+  it("reuses human-addressed connection intents across runs and ordinary comments", async () => {
     const { companyId, issueId } = await seedConfirmationIssue("Connection intent");
     const agentId = randomUUID();
     const firstRunId = randomUUID();
@@ -176,6 +176,7 @@ describeEmbeddedPostgres("issueThreadInteractionService", () => {
       runtimeConfig: {},
       permissions: {},
     });
+    await db.update(issues).set({ assigneeAgentId: agentId, status: "in_progress" }).where(eq(issues.id, issueId));
     await db.insert(heartbeatRuns).values([
       {
         id: firstRunId,
@@ -241,15 +242,8 @@ describeEmbeddedPostgres("issueThreadInteractionService", () => {
         idempotencyKey: `connection-intent:${secondRunId}:notion`,
       },
     );
-    const superseded = await interactionsSvc.getById(first.id);
-    expect(superseded).toMatchObject({
-      status: "expired",
-      result: {
-        version: 1,
-        outcome: "superseded",
-        supersededByInteractionId: newer.id,
-      },
-    });
+    expect(newer.id).toBe(first.id);
+    expect(await interactionsSvc.getById(first.id)).toMatchObject({ status: "pending" });
 
     const [expiredByComment] = await interactionsSvc.expireRequestConfirmationsSupersededByComment(
       { id: issueId, companyId },
@@ -261,15 +255,7 @@ describeEmbeddedPostgres("issueThreadInteractionService", () => {
       },
       { userId: "user-board" },
     );
-    expect(expiredByComment).toMatchObject({
-      id: newer.id,
-      status: "expired",
-      result: {
-        version: 1,
-        outcome: "expired",
-        reason: "Superseded by a newer user comment",
-      },
-    });
+    expect(expiredByComment).toBeUndefined();
   });
 
   it("persists addressees without allowing them to bypass human-only governance", async () => {

server/src/__tests__/issues-service.test.ts

@@ -6,6 +6,7 @@ import {
   activityLog,
   agents,
   companies,
+  companyMemberships,
   createDb,
   documentRevisions,
   documents,
@@ -26,6 +27,9 @@ import {
   projectWorkspaces,
   projects,
   workspaceOperations,
+  toolApplications,
+  toolConnections,
+  toolOauthStates,
 } from "@paperclipai/db";
 import {
   getEmbeddedPostgresTestSupport,
@@ -400,6 +404,7 @@ describeEmbeddedPostgres("issueService.list participantAgentId", () => {
     await db.delete(heartbeatRuns);
     await db.delete(agents);
     await db.delete(instanceSettings);
+    await db.delete(companyMemberships);
     await db.delete(companies);
   });
 
@@ -610,6 +615,53 @@ describeEmbeddedPostgres("issueService.list participantAgentId", () => {
     });
   });
 
+  it("expires a pending connection and its OAuth state when reassigned to a user without a status change", async () => {
+    const companyId = await seedAssignableAgentCompany();
+    const agentId = randomUUID();
+    const userId = randomUUID();
+    await db.insert(agents).values(agentRow(companyId, { id: agentId, name: "ConnectionRequester" }));
+    await db.insert(companyMemberships).values({
+      companyId, principalType: "user", principalId: userId, status: "active", membershipRole: "member",
+    });
+    const issue = await svc.create(companyId, {
+      title: "Waiting for a connection", status: "in_review", priority: "medium", assigneeAgentId: agentId,
+    });
+    const [application] = await db.insert(toolApplications).values({
+      companyId, name: "Connection app", type: "mcp",
+    }).returning();
+    const [connection] = await db.insert(toolConnections).values({
+      companyId, applicationId: application!.id, name: "Notion", uid: randomUUID(),
+      transport: "mcp_remote", authKind: "oauth",
+    }).returning();
+    const [interaction] = await db.insert(issueThreadInteractions).values({
+      companyId, issueId: issue.id, kind: "connection_intent", status: "pending",
+      createdByAgentId: agentId, addresseeUserId: "local-board",
+      payload: {
+        version: 1, serviceSlug: "notion", serviceName: "Notion",
+        requestingAgentId: agentId, requestingAgentName: "ConnectionRequester", phase: "authorizing",
+      },
+    }).returning();
+    const oauthState = randomUUID();
+    await db.insert(toolOauthStates).values({
+      state: oauthState, companyId, connectionId: connection!.id, issueId: issue.id,
+      interactionId: interaction!.id, codeVerifier: "test-verifier",
+      createdByActorType: "user", createdByActorId: "local-board",
+      expiresAt: new Date(Date.now() + 60_000),
+    });
+
+    const updated = await svc.update(issue.id, {
+      assigneeAgentId: null, assigneeUserId: userId, actorUserId: "local-board",
+    });
+    expect(updated).toMatchObject({ status: "in_review", assigneeAgentId: null, assigneeUserId: userId });
+    await expect(db.select().from(issueThreadInteractions).where(eq(issueThreadInteractions.id, interaction!.id)))
+      .resolves.toEqual([expect.objectContaining({
+        status: "expired",
+        result: { version: 1, outcome: "expired", reason: "The task assignment changed" },
+        resolvedAt: expect.any(Date),
+      })]);
+    await expect(db.select().from(toolOauthStates).where(eq(toolOauthStates.state, oauthState))).resolves.toEqual([]);
+  });
+
   it("expires pending thread interactions on any service-level terminal transition", async () => {
     const companyId = await seedAssignableAgentCompany();
     const issue = await svc.create(companyId, {

server/src/__tests__/native-status-arbiter-corpus.test.ts

@@ -2190,6 +2190,23 @@ describe("P6-31 Section 18.13 executable status-authority corpus", () => {
     ]);
   });
 
+  it("binds a tools-refresh continuation to its existing durable wake without a duplicate", async () => {
+    const template = corpus.fixtures.find((candidate) => candidate.mode === "native")!;
+    const fixture = { ...template, id: "in-feed-tools-refresh", given: { ...template.given, priorIssueStatus: "in_progress" } };
+    const seeded = await seedFixture(fixture);
+    const key = `connection-intent:tools:${seeded.runId}:fixture-digest`;
+    const [wake] = await db.insert(agentWakeupRequests).values({ companyId, agentId, source: "assignment", status: "queued", idempotencyKey: key,
+      payload: { issueId: seeded.issueId, mutation: "connection_tools_refreshed" } }).returning();
+    const decision: NativeStatusDecision = { policyVersion: NATIVE_STATUS_ARBITER_POLICY_VERSION, statusAction: "in_progress", toStatus: "in_progress",
+      reasonCode: "live_continuation_registered", unblockDescriptor: null,
+      effects: [{ kind: "enqueue_continuation", continuationKind: "same_agent", summary: "Use updated tools", idempotencyKey: key, agentId }] };
+    await commitNativeStatusDecision({ db, companyId, issueId: seeded.issueId, runId: seeded.runId, assessmentId: seeded.assessmentId,
+      priorStatus: "in_progress", priorStatusVersion: 0, priorDecisionId: null, decision });
+    const effects = await db.select().from(statusDecisionEffects).where(eq(statusDecisionEffects.issueId, seeded.issueId));
+    expect(effects.filter((effect) => effect.effectKind === "enqueue_continuation")).toEqual([expect.objectContaining({ targetId: wake!.id, targetType: "agent_wakeup_request" })]);
+    expect(await db.select().from(agentWakeupRequests).where(eq(agentWakeupRequests.idempotencyKey, key))).toHaveLength(1);
+  });
+
   it("fails the transaction closed for an unknown status effect", async () => {
     const fixture = corpus.fixtures.find((candidate) => candidate.mode === "native");
     if (!fixture) throw new Error("native corpus fixture missing");

server/src/__tests__/runner-connection-eval-fixtures.test.ts

@@ -0,0 +1,75 @@
+import { randomUUID } from "node:crypto";
+import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
+import { startRunnerApiTestServer } from "./helpers/runner-api-server.js";
+
+describe("connection eval real-server fixtures", () => {
+  let server: Awaited<ReturnType<typeof startRunnerApiTestServer>>;
+  beforeAll(async () => {
+    vi.stubEnv("PAPERCLIP_AGENT_JWT_SECRET", randomUUID());
+    server = await startRunnerApiTestServer();
+  }, 60_000);
+  afterAll(async () => { await server?.close(); vi.unstubAllEnvs(); });
+  const call = (fixture: Awaited<ReturnType<typeof server.fixture>>, tool: string, args: unknown) => fixture.authority.execute({ tool, callId: randomUUID(), arguments: args });
+
+  it("binds fresh discovery and card creation to an authenticated responsible user", async () => {
+    const fixture = await server.fixture({ connectionScenario: "fresh" });
+    expect((await fixture.snapshot()).connectionInteractions).toEqual([]);
+    expect(await call(fixture, "connections_search", { query: "Notion" })).toMatchObject({ results: [{ service: "notion", state: "available" }] });
+    await call(fixture, "connection_request", { service: "notion" });
+    const state = await fixture.snapshot();
+    expect(state.connectionInteractions).toEqual([expect.objectContaining({ addresseeUserId: fixture.responsibleUserId, sourceRunId: fixture.runId, status: "pending", payload: expect.objectContaining({ requestingAgentId: fixture.agentId }) })]);
+    expect(state.connections).toEqual([]);
+  });
+
+  it("reuses a pending card from a previous run and preserves a declined outcome", async () => {
+    const pending = await server.fixture({ connectionScenario: "pending" });
+    expect(await call(pending, "connection_request", { service: "notion" })).toMatchObject({ interactionId: pending.pendingInteractionId });
+    expect((await pending.snapshot()).connectionInteractions).toHaveLength(1);
+    expect((await pending.snapshot()).connectionInteractions[0]!.sourceRunId).not.toBe(pending.runId);
+    const declined = await server.fixture({ connectionScenario: "declined" });
+    await expect(call(declined, "connection_request", { service: "notion" })).rejects.toThrow("declined");
+    const state = await declined.snapshot();
+    expect(state.connectionInteractions).toEqual([expect.objectContaining({ id: declined.pendingInteractionId, status: "rejected" })]);
+    expect(state.connectionIntentDeliveries).toHaveLength(1);
+  });
+
+  it("discovers authorized indexed custom metadata without fetching the inert provider", async () => {
+    const fixture = await server.fixture({ connectionScenario: "custom" });
+    const fetchSpy = vi.spyOn(globalThis, "fetch").mockRejectedValue(new Error("Unexpected provider call"));
+    try {
+      expect(await call(fixture, "connections_search", { query: "heliotrope" })).toMatchObject({ results: [{ service: fixture.customConnectionService, state: "needs_user_action", source: "configured" }] });
+      await call(fixture, "connection_request", { service: fixture.customConnectionService });
+      expect(fetchSpy).not.toHaveBeenCalled();
+      const state = await fixture.snapshot();
+      expect(state.installs).toEqual([]);
+      expect(state.connectionInteractions).toHaveLength(1);
+      expect(JSON.stringify(state.connections)).not.toContain("transportConfig");
+    } finally { fetchSpy.mockRestore(); }
+  });
+
+  it("hides foreign connections and denies stale ownership", async () => {
+    const foreign = await server.fixture({ connectionScenario: "foreign" });
+    expect(await call(foreign, "connections_search", { query: "heliotrope" })).toMatchObject({ results: [] });
+    await expect(call(foreign, "connection_request", { service: foreign.foreignConnectionService })).rejects.toThrow("not found");
+    expect((await foreign.snapshot()).connectionInteractions).toEqual([]);
+    const stale = await server.fixture({ connectionScenario: "stale_owner" });
+    await expect(call(stale, "connection_request", { service: "notion" })).rejects.toThrow();
+    expect((await stale.snapshot()).connectionInteractions).toEqual([]);
+  });
+
+  it("reports installed and permitted fixture Notion as ready without a card", async () => {
+    const fixture = await server.fixture({ connectionScenario: "ready" });
+    expect(await call(fixture, "connections_search", { query: "Notion" })).toMatchObject({ results: [{ service: "notion", state: "ready" }] });
+    expect(await call(fixture, "connection_request", { service: "notion" })).toMatchObject({ state: "ready", interactionId: null });
+    expect((await fixture.snapshot()).connectionInteractions).toEqual([]);
+  });
+
+  it("resets paired attempts without carrying prior connections and rejects unknown scenarios", async () => {
+    const first = await server.fixture({ connectionScenario: "ready", reset: true });
+    const second = await server.fixture({ connectionScenario: "fresh", reset: true });
+    expect(second.responsibleUserId).toBe(first.responsibleUserId);
+    expect(second.companyId).toBe(first.companyId);
+    expect((await second.snapshot()).connections).toEqual([]);
+    await expect(server.fixture({ connectionScenario: "unknown" as never })).rejects.toThrow("Unknown connection eval scenario");
+  });
+});

server/src/__tests__/server-startup-feedback-export.test.ts

@@ -333,6 +333,12 @@ vi.mock("../services/index.js", () => ({
   })),
 }));
 
+vi.mock("../services/connection-intent-delivery.js", () => ({
+  connectionIntentDeliveryService: vi.fn(() => ({
+    sweepPending: vi.fn(async () => ({ scanned: 0, failed: 0 })),
+  })),
+}));
+
 vi.mock("../services/question-response-delivery.js", () => ({
   questionResponseDeliveryService: vi.fn(() => ({
     sweepPending: vi.fn(async () => ({

server/src/__tests__/tool-access-service.test.ts

@@ -4629,6 +4629,27 @@ describeEmbeddedPostgres("tool access service", () => {
       .resolves.toHaveLength(1);
   });
 
+  it("reconnects an exact active custom MCP connection without duplicating its identity", async () => {
+    const company = await createCompany(db);
+    const service = createTestToolAccessService(db);
+    mockToolsList([{ name: "archive_read", annotations: { readOnlyHint: true } }]);
+    const first = await service.connectGalleryApp(company.id, { link: "https://fixture.example/mcp", authMode: "none", name: "Archive" }, { actorType: "user", actorId: "board" });
+    await db.update(toolConnections).set({ status: "active", healthStatus: "error" }).where(eq(toolConnections.id, first.connectionId));
+    mockToolsList([{ name: "archive_read", annotations: { readOnlyHint: true } }]);
+    const reconnected = await service.connectGalleryApp(company.id, { link: "https://fixture.example/mcp", authMode: "none", reconnectConnectionId: first.connectionId }, { actorType: "user", actorId: "board" });
+    expect(reconnected.connectionId).toBe(first.connectionId);
+    const originalAgent = await createAgent(db, company.id);
+    const requester = await createAgent(db, company.id);
+    const ids = reconnected.actions.readOnly.map((action) => action.catalogEntryId);
+    await service.finishGalleryAppConnection(company.id, first.connectionId, { enabledCatalogEntryIds: ids, askFirstCatalogEntryIds: [], access: { agentIds: [originalAgent.id] } });
+    const additive = await service.finishGalleryAppConnection(company.id, first.connectionId, { enabledCatalogEntryIds: ids, askFirstCatalogEntryIds: [], access: { agentIds: [requester.id] }, preserveExistingAccess: true });
+    expect(additive.profileBindings.map((binding) => binding.targetId)).toEqual(expect.arrayContaining([originalAgent.id, requester.id]));
+    expect(await db.select().from(toolConnections).where(eq(toolConnections.companyId, company.id))).toHaveLength(1);
+    await expect(service.connectGalleryApp(company.id, { galleryKey: "notion", reconnectConnectionId: first.connectionId }, { actorType: "user", actorId: "board" })).rejects.toThrow("preserve the configured provider");
+    const other = await createCompany(db);
+    await expect(service.connectGalleryApp(other.id, { link: "https://fixture.example/mcp", reconnectConnectionId: first.connectionId }, { actorType: "user", actorId: "board" })).rejects.toThrow("not found");
+  });
+
   it("refuses a personal identity when no named user is making the request", async () => {
     const company = await createCompany(db);
     const service = createTestToolAccessService(db);
@@ -6446,13 +6467,34 @@ describeEmbeddedPostgres("tool access service", () => {
     )).length).toBe(versionCountBeforeAccessRevocation);
   });
 
-  it("activates and discovers actions for a fresh personal OAuth callback before access is finalized", async () => {
+  it.each(["page", "task"] as const)("activates and discovers actions for a fresh personal OAuth callback from %s without widening task access", async (host) => {
     vi.stubEnv("PAPERCLIP_TOOL_OAUTH_SLACK_CLIENT_ID", "slack-client-id");
     vi.stubEnv("PAPERCLIP_TOOL_OAUTH_SLACK_CLIENT_SECRET", "slack-client-secret");
     const company = await createCompany(db);
     const userId = `oauth-owner-${randomUUID()}`;
     await grantBoardUser(db, company.id, userId, [], "owner");
     const agent = await createAgent(db, company.id);
+    const otherAgent = await createAgent(db, company.id);
+    const { issue, run } = await createIssueAndRun(db, company.id, agent.id);
+    const interaction = host === "task"
+      ? (await db.insert(issueThreadInteractions).values({
+          companyId: company.id,
+          issueId: issue.id,
+          sourceRunId: run.id,
+          kind: "connection_intent",
+          status: "pending",
+          createdByAgentId: agent.id,
+          addresseeUserId: userId,
+          payload: {
+            version: 1,
+            serviceSlug: "slack",
+            serviceName: "Slack",
+            requestingAgentId: agent.id,
+            requestingAgentName: agent.name,
+            phase: "authorizing",
+          },
+        }).returning())[0]
+      : undefined;
     const service = createTestToolAccessService(db);
     const connected = await service.connectGalleryApp(company.id, {
       galleryKey: "slack",
@@ -6463,6 +6505,7 @@ describeEmbeddedPostgres("tool access service", () => {
       redirectUri: "https://paperclip.example/api/tools/oauth/callback",
       actor: { actorType: "user", actorId: userId },
       subjectUserId: userId,
+      interactionId: interaction?.id,
     });
     vi.spyOn(globalThis, "fetch").mockImplementation(async (url, init) => {
       const href = String(url);
@@ -6526,9 +6569,9 @@ describeEmbeddedPostgres("tool access service", () => {
       eq(toolPolicies.enabled, true),
     ))).resolves.toEqual([]);
     const callbackPolicy = toolAccessPolicyService(db);
-    const decide = (entry: (typeof completed.catalog)[number]) => callbackPolicy.decide({
+    const decide = (entry: (typeof completed.catalog)[number], agentId = agent.id) => callbackPolicy.decide({
       companyId: company.id,
-      actor: { actorType: "agent", actorId: agent.id, agentId: agent.id },
+      actor: { actorType: "agent", actorId: agentId, agentId },
       request: {
         connectionId: connected.connectionId,
         catalogEntryId: entry.id,
@@ -6536,14 +6579,22 @@ describeEmbeddedPostgres("tool access service", () => {
         arguments: {},
       },
     });
-    await expect(decide(searchMessagesEntry)).resolves.toMatchObject({
-      decision: "allow",
-      reasonCode: "allow_profile",
-    });
-    await expect(decide(sendMessageEntry)).resolves.toMatchObject({
-      decision: "allow",
-      reasonCode: "allow_profile",
-    });
+    for (const entry of [searchMessagesEntry, sendMessageEntry]) {
+      await expect(decide(entry)).resolves.toMatchObject(host === "task"
+        ? { decision: "deny" }
+        : { decision: "allow", reasonCode: "allow_profile" });
+    }
+    if (host === "task") {
+      await expect(db.select().from(toolProfileBindings).where(eq(
+        toolProfileBindings.profileId, callbackProfile!.id,
+      ))).resolves.toEqual([]);
+      await expect(db.select().from(toolConnectionInstalls).where(eq(
+        toolConnectionInstalls.connectionId, connected.connectionId,
+      ))).resolves.toEqual([]);
+      await expect(db.select().from(issueThreadInteractions).where(eq(
+        issueThreadInteractions.id, interaction!.id,
+      ))).resolves.toEqual([expect.objectContaining({ status: "pending", result: null })]);
+    }
     const [personalGrant] = await db.select().from(connectionGrants).where(and(
       eq(connectionGrants.connectionId, connected.connectionId),
       eq(connectionGrants.subjectUserId, userId),
@@ -6556,15 +6607,41 @@ describeEmbeddedPostgres("tool access service", () => {
 
     const finished = await service.finalizeOAuthAccess(company.id, connected.connectionId, {
       grantKind: "user",
-    }, { actorType: "user", actorId: userId });
+    }, { actorType: "user", actorId: userId }, host === "task" ? agent.id : undefined);
     expect(finished.profileEntries).toHaveLength(2);
     expect(finished.profileBindings).toEqual([
-      expect.objectContaining({ targetType: "company", targetId: company.id }),
+      expect.objectContaining(host === "task"
+        ? { targetType: "agent", targetId: agent.id }
+        : { targetType: "company", targetId: company.id }),
     ]);
     await expect(db.select().from(toolConnectionInstalls).where(and(
       eq(toolConnectionInstalls.connectionId, connected.connectionId),
       eq(toolConnectionInstalls.targetType, "company"),
-    ))).resolves.toHaveLength(1);
+    ))).resolves.toHaveLength(host === "task" ? 0 : 1);
+    if (host === "task") {
+      await expect(decide(searchMessagesEntry)).resolves.toMatchObject({ decision: "allow" });
+      await expect(decide(searchMessagesEntry, otherAgent.id)).resolves.toMatchObject({ decision: "deny" });
+      // Granting a second requester and retrying the first must preserve both installs.
+      for (const requestingAgentId of [otherAgent.id, agent.id]) {
+        await service.finalizeOAuthAccess(company.id, connected.connectionId, {
+          grantKind: "user",
+        }, { actorType: "user", actorId: userId }, requestingAgentId);
+      }
+      const bindings = await db.select().from(toolProfileBindings).where(eq(
+        toolProfileBindings.profileId, callbackProfile!.id,
+      ));
+      expect(bindings.map(({ targetType, targetId }) => ({ targetType, targetId }))).toEqual(
+        expect.arrayContaining([agent.id, otherAgent.id].map((targetId) => ({ targetType: "agent", targetId }))),
+      );
+      expect(bindings).toHaveLength(2);
+      const installs = await db.select().from(toolConnectionInstalls).where(eq(
+        toolConnectionInstalls.connectionId, connected.connectionId,
+      ));
+      expect(installs.map(({ targetType, targetId }) => ({ targetType, targetId }))).toEqual(
+        expect.arrayContaining([agent.id, otherAgent.id].map((targetId) => ({ targetType: "agent", targetId }))),
+      );
+      expect(installs).toHaveLength(2);
+    }
     await expect(service.startOAuth(company.id, connected.connectionId, {
       redirectUri: "https://paperclip.example/api/tools/oauth/callback",
       actor: { actorType: "user", actorId: `different-user-${randomUUID()}` },
@@ -6586,6 +6663,7 @@ describeEmbeddedPostgres("tool access service", () => {
     const reconnect = await service.startOAuth(company.id, connected.connectionId, {
       redirectUri: "https://paperclip.example/api/tools/oauth/callback",
       actor: { actorType: "user", actorId: userId },
+      interactionId: interaction?.id,
     });
     await expect(service.peekOAuthState(new URL(reconnect.authorizationUrl).searchParams.get("state")!))
       .resolves.toMatchObject({ subjectUserId: userId });
@@ -6610,6 +6688,16 @@ describeEmbeddedPostgres("tool access service", () => {
     ));
     expect(revivedSecrets).toHaveLength(2);
     expect(revivedSecrets.every((secret) => secret.latestVersion === 2)).toBe(true);
+    if (host === "task") {
+      const installs = await db.select().from(toolConnectionInstalls).where(eq(
+        toolConnectionInstalls.connectionId, connected.connectionId,
+      ));
+      expect(installs).toHaveLength(2);
+      expect(installs.every((install) => install.targetType === "agent")).toBe(true);
+      for (const allowedAgentId of [agent.id, otherAgent.id]) {
+        await expect(decide(searchMessagesEntry, allowedAgentId)).resolves.toMatchObject({ decision: "allow" });
+      }
+    }
   });
 
   it("promotes a personal OAuth identity only after Everyone in the company is chosen", async () => {
@@ -6934,16 +7022,22 @@ describeEmbeddedPostgres("tool access service", () => {
     expect(location.searchParams.get("code")).toBe("oauth_authorization_denied");
   });
 
-  it("starts and completes OAuth app sign-in with PKCE state and secret-backed tokens", async () => {
+  it.each([
+    "https://paperclip-public.example",
+    "http://127.0.0.1:3200",
+    "http://localhost:3200",
+  ])("starts and completes OAuth with the same redirect URI at %s", async (origin) => {
     vi.stubEnv("PAPERCLIP_TOOL_OAUTH_SLACK_CLIENT_ID", "slack-client-id");
     vi.stubEnv("PAPERCLIP_TOOL_OAUTH_SLACK_CLIENT_SECRET", "slack-client-secret");
-    vi.stubEnv("PAPERCLIP_PUBLIC_URL", "https://paperclip-public.example");
+    vi.stubEnv("PAPERCLIP_PUBLIC_URL", origin.startsWith("https:") ? origin : "");
     const company = await createCompany(db);
     await grantBoardUser(db, company.id, "board-user", ["tools:manage_connections"]);
     const app = createRouteApp(db);
 
     const connectRes = await request(app)
       .post(`/api/companies/${company.id}/tools/apps/connect`)
+      .set("Host", new URL(origin).host)
+      .set("Origin", origin)
       .send({ galleryKey: "slack", name: "Slack workspace" });
 
     expect(connectRes.status).toBe(201);
@@ -6958,7 +7052,7 @@ describeEmbeddedPostgres("tool access service", () => {
     expect(startUrl.searchParams.get("client_id")).toBe("slack-client-id");
     expect(startUrl.searchParams.get("code_challenge_method")).toBe("S256");
     expect(startUrl.searchParams.get("code_challenge")).toMatch(/^[A-Za-z0-9_-]{43}$/);
-    expect(startUrl.searchParams.get("redirect_uri")).toBe("https://paperclip-public.example/api/tools/oauth/callback");
+    expect(startUrl.searchParams.get("redirect_uri")).toBe(`${origin}/api/tools/oauth/callback`);
     const state = startUrl.searchParams.get("state");
     expect(state).toBeTruthy();
     await expect(db.select().from(toolOauthStates)).resolves.toEqual([
@@ -6980,7 +7074,7 @@ describeEmbeddedPostgres("tool access service", () => {
         expect(body.get("code")).toBe("oauth-code");
         expect(body.get("client_secret")).toBe("slack-client-secret");
         expect(body.get("code_verifier")).toBeTruthy();
-        expect(body.get("redirect_uri")).toBe("https://paperclip-public.example/api/tools/oauth/callback");
+        expect(body.get("redirect_uri")).toBe(`${origin}/api/tools/oauth/callback`);
         return {
           ok: true,
           json: async () => ({
@@ -7011,6 +7105,7 @@ describeEmbeddedPostgres("tool access service", () => {
 
     const callbackRes = await request(app)
       .get("/api/tools/oauth/callback")
+      .set("Host", new URL(origin).host)
       .query({ state, code: "oauth-code" });
 
     expect(callbackRes.status).toBe(200);
@@ -7033,12 +7128,15 @@ describeEmbeddedPostgres("tool access service", () => {
 
     const redirectConnectRes = await request(app)
       .post(`/api/companies/${company.id}/tools/apps/connect`)
+      .set("Host", new URL(origin).host)
+      .set("Origin", origin)
       .send({ galleryKey: "slack", name: "Slack redirect" })
       .expect(201);
     const redirectState = new URL(redirectConnectRes.body.auth.startUrl).searchParams.get("state");
     expect(redirectState).toBeTruthy();
     const redirectCallbackRes = await request(app)
       .get("/api/tools/oauth/callback")
+      .set("Host", new URL(origin).host)
       .set("Accept", "text/html")
       .query({ state: redirectState, code: "oauth-code" });
 

server/src/index.ts

@@ -1,3 +1,4 @@
+import { connectionIntentDeliveryService } from "./services/connection-intent-delivery.js";
 /// <reference path="./types/express.d.ts" />
 // Kicks off the OTel bootstrap as early as possible (no-op unless
 // OTEL_EXPORTER_OTLP_ENDPOINT is set). startServer() awaits
@@ -1182,6 +1183,7 @@ async function startServerWithDatabaseTeardown(
   const ENVIRONMENT_LEASE_CLEANUP_SWEEP_BACKOFF_MS = 5 * 60 * 1000;
   const environmentLeaseCleanupHeartbeat =
     heartbeat ?? heartbeatService(db as any, { pluginWorkerManager });
+  const connectionDeliveries = connectionIntentDeliveryService(db as any, environmentLeaseCleanupHeartbeat);
   const questionResponseDeliveries = questionResponseDeliveryService(db as any, {
     heartbeat: environmentLeaseCleanupHeartbeat,
     resolveNativeQuestion: (interaction) => deliverNativeQuestionResponse(db as any, interaction),
@@ -1236,6 +1238,7 @@ async function startServerWithDatabaseTeardown(
       }));
   };
 
+  await connectionDeliveries.sweepPending();
   await questionResponseDeliveries.sweepPending().then((result) => {
     if (result.scanned > 0) {
       logger.info(result, "startup question-response delivery sweep completed");
@@ -1680,6 +1683,7 @@ async function startServerWithDatabaseTeardown(
             logger.error({ err }, "periodic secret proposal expiry sweep failed");
           }));
 
+        trackHeartbeatSchedulerWork(connectionDeliveries.sweepPending().catch((err) => logger.error({ err }, "connection continuation delivery failed")));
         trackHeartbeatSchedulerWork(questionResponseDeliveries.sweepPending()
           .then((result) => {
             if (result.scanned > 0) {

server/src/modules/run-dispatch/adapters/postgres.ts

@@ -527,6 +527,8 @@ export function createPostgresRunDispatchAdapter(
       issueAssigneeAgentId: issue?.assigneeAgentId ?? null,
       issueExecutionRunId: issue?.executionRunId ?? null,
       isResolvedInteractionContinuation,
+      isConnectionContinuation: (isResolvedInteractionContinuation && context.interactionKind === "connection_intent")
+        || context.source === "connection_tools.refreshed",
       isInteractionWake,
       isAuthorizedSourceScopedRecovery,
       isNonAssigneeWorkspaceBusyRetry: isNonAssigneeWorkspaceBusyRetry(retryReason, context),

server/src/modules/run-dispatch/domain/policy.test.ts

@@ -342,6 +342,40 @@ describe("decideQueuedRunStaleness", () => {
     expect(decision).toMatchObject({ errorCode });
   });
 
+  describe.each([
+    { name: "resolved connection", isResolvedInteractionContinuation: true, wakeReason: "issue_interaction_resolved" },
+    { name: "tool snapshot refresh", isResolvedInteractionContinuation: false, wakeReason: "connection_tools_updated" },
+  ])("$name continuation", ({ isResolvedInteractionContinuation, wakeReason }) => {
+    const connectionFacts = (): QueuedRunFacts => ({
+      ...baseStalenessFacts(),
+      isConnectionContinuation: true,
+      isResolvedInteractionContinuation,
+      wakeReason,
+      issueStatus: "in_review",
+      reviewParticipant: { ...NO_PARTICIPANT, isInReview: true },
+    });
+
+    it("continues an owned task waiting in review after connection access becomes ready", () => {
+      expect(decideQueuedRunStaleness(connectionFacts(), NOW)).toEqual({ stale: false });
+    });
+
+    it.each(["done", "cancelled", "todo", "backlog", "blocked"])("rejects a task in %s", (issueStatus) => {
+      expect(decideQueuedRunStaleness({ ...connectionFacts(), issueStatus }, NOW)).toMatchObject({
+        stale: true,
+        errorCode: "issue_not_in_progress",
+      });
+    });
+
+    it("rejects a reassigned task even when an interaction wake normally bypasses ownership", () => {
+      expect(decideQueuedRunStaleness({
+        ...connectionFacts(),
+        issueAssigneeAgentId: "agent-2",
+        isInteractionWake: true,
+        wakeCommentIdPresent: true,
+      }, NOW)).toMatchObject({ stale: true, errorCode: "issue_assignee_changed" });
+    });
+  });
+
   it("does not cancel a parked continuation summary when the classifier says it does not park the executor", () => {
     const facts: QueuedRunFacts = {
       ...baseStalenessFacts(),

server/src/modules/run-dispatch/domain/policy.ts

@@ -130,6 +130,8 @@ export type QueuedRunFacts = {
   issueExecutionRunId: string | null;
 
   isResolvedInteractionContinuation: boolean;
+  /** A connection resolution or tool refresh can resume an agent waiting in review. */
+  isConnectionContinuation?: boolean;
   isInteractionWake: boolean;
   isAuthorizedSourceScopedRecovery: boolean;
   isNonAssigneeWorkspaceBusyRetry: boolean;
@@ -458,10 +460,10 @@ export function decideQueuedRunStaleness(
     };
   }
 
-  if (facts.isResolvedInteractionContinuation) {
+  if (facts.isResolvedInteractionContinuation || facts.isConnectionContinuation) {
     const earlyStatus = decideIssueStatus({
       status: facts.issueStatus,
-      requiresInProgress: true,
+      requiresInProgress: !(facts.isConnectionContinuation && facts.issueStatus === "in_review"),
       terminalBypass: true,
     });
     if (earlyStatus === "not_in_progress") {

server/src/routes/connection-intents.test.ts

@@ -75,7 +75,7 @@ describe("connection intent continuation wake contract", () => {
       expect(wakeup).toHaveBeenCalledWith(
         "agent-123",
         expect.objectContaining({
-          idempotencyKey: `interaction:interaction-123:${status}`,
+          idempotencyKey: `connection-intent:interaction-123:${status}`,
           requestedByActorType: "user",
           requestedByActorId: "user-123",
           contextSnapshot: expect.objectContaining({
@@ -89,7 +89,7 @@ describe("connection intent continuation wake contract", () => {
     },
   );
 
-  it.each(["backlog", "todo", "in_review", "done", "blocked", "cancelled"])(
+  it.each(["backlog", "todo", "done", "blocked", "cancelled"])(
     "does not wake a parked or closed %s task",
     async (issueStatus) => {
       const wakeup = vi.fn().mockResolvedValue(undefined);

server/src/routes/connection-intents.ts

@@ -1,3 +1,4 @@
+import { connectionIntentDeliveryService } from "../services/connection-intent-delivery.js";
 import { Router, type Request } from "express";
 import type { Db } from "@paperclipai/db";
 import {
@@ -35,27 +36,8 @@ function resultContent(value: unknown) {
   };
 }
 
-export const RUNTIME_CONNECTION_TOOL_DEFINITIONS = [
-  {
-    name: "connections_search",
-    description: CONNECTIONS_SEARCH_TOOL_DESCRIPTION,
-    inputSchema: {
-      type: "object",
-      properties: { query: { type: "string" } },
-      additionalProperties: false,
-    },
-  },
-  {
-    name: "connection_request",
-    description: CONNECTION_REQUEST_TOOL_DESCRIPTION,
-    inputSchema: {
-      type: "object",
-      properties: { service: { type: "string" } },
-      required: ["service"],
-      additionalProperties: false,
-    },
-  },
-] as const;
+export { RUNTIME_CONNECTION_TOOL_DEFINITIONS } from "../services/connection-tool-definitions.js";
+import { RUNTIME_CONNECTION_TOOL_DEFINITIONS } from "../services/connection-tool-definitions.js";
 
 /** Public, token-authenticated routes mounted before the general actor middleware. */
 export function runtimeConnectionIntentRoutes(db: Db) {
@@ -158,56 +140,7 @@ export function runtimeConnectionIntentRoutes(db: Db) {
 
 type Heartbeat = ReturnType<typeof heartbeatService>;
 
-export async function wakeConnectionIntentAfterResolution(
-  heartbeat: Pick<Heartbeat, "wakeup">,
-  input: {
-    loaded: {
-      issue: { id: string; assigneeAgentId: string | null; status: string };
-      interaction: { id: string; resolvedAt?: string | Date | null };
-    };
-    status: string;
-    actorId: string;
-  },
-) {
-  const agentId = input.loaded.issue.assigneeAgentId;
-  if (!agentId || input.loaded.issue.status !== "in_progress") return;
-  const resolvedAt = input.loaded.interaction.resolvedAt;
-  const interactionResolvedAt = resolvedAt instanceof Date ? resolvedAt.toISOString() : resolvedAt;
-  await heartbeat.wakeup(agentId, {
-    source: "automation",
-    triggerDetail: "system",
-    reason: "issue_commented",
-    payload: {
-      issueId: input.loaded.issue.id,
-      interactionId: input.loaded.interaction.id,
-      interactionKind: "connection_intent",
-      interactionStatus: input.status,
-      mutation: "interaction",
-    },
-    idempotencyKey: `interaction:${input.loaded.interaction.id}:${input.status}`,
-    requestedByActorType: "user",
-    requestedByActorId: input.actorId,
-    contextSnapshot: {
-      issueId: input.loaded.issue.id,
-      taskId: input.loaded.issue.id,
-      interactionId: input.loaded.interaction.id,
-      interactionKind: "connection_intent",
-      interactionStatus: input.status,
-      mutation: "interaction",
-      wakeReason: "issue_commented",
-      source: "connection_intent.resolved",
-      ...(interactionResolvedAt
-        ? { interactionResolvedAt }
-        : {}),
-      forceFreshSession: true,
-    },
-    issueStateGuard: {
-      statuses: ["in_progress"],
-      assigneeAgentId: agentId,
-    },
-  });
-}
-
+export { wakeConnectionIntentAfterResolution } from "../services/connection-intent-delivery.js";
 export function connectionIntentBoardRoutes(db: Db, heartbeat: Heartbeat) {
   const router = Router();
   const service = connectionIntentService(db);
@@ -243,14 +176,7 @@ export function connectionIntentBoardRoutes(db: Db, heartbeat: Heartbeat) {
     status: string;
     actorId: string;
   }) {
-    // The operator may park or reassign the issue while the connection work
-    // and activity write are in flight. Re-read immediately before enqueueing
-    // so the wake decision is not made from addressedIntent's stale snapshot.
-    const current = await service.loadIntent(input.loaded.interaction.id);
-    await wakeConnectionIntentAfterResolution(heartbeat, {
-      ...input,
-      loaded: current,
-    });
+    await connectionIntentDeliveryService(db, heartbeat).tryDeliver(input.loaded.interaction.id);
   }
 
   router.get("/connection-intents/:interactionId/setup-options", async (req, res) => {

server/src/routes/tool-access.ts

@@ -77,7 +77,7 @@ import { isLoopbackHost } from "../url-utils.js";
 import { trustedBoardMutationOrigin } from "../middleware/board-mutation-guard.js";
 import { connectionIntentService } from "../services/connection-intents.js";
 import { redactRemoteUrlCredential } from "../services/remote-url-credentials.js";
-import { wakeConnectionIntentAfterResolution } from "./connection-intents.js";
+import { connectionIntentDeliveryService } from "../services/connection-intent-delivery.js";
 import type { heartbeatService } from "../services/heartbeat.js";
 
 const COMPANY_INSTALL_DENIAL_REASON =
@@ -268,22 +268,11 @@ export function toolAccessRoutes(
           canManageOrganizationGrant: input.canManageOrganizationGrant,
           bypassCurrentMembershipCheck: input.bypassCurrentMembershipCheck,
         })
-      : input.outcome === "declined"
-        ? await connectionIntents.decline(
-            input.interactionId,
-            input.userId,
-            "Authorization was declined in the provider window",
-            { bypassCurrentMembershipCheck: input.bypassCurrentMembershipCheck },
-          )
-        : await connectionIntents.updatePhase(input.interactionId, "needs_retry", input.userId, {
+      : await connectionIntents.updatePhase(input.interactionId, "needs_retry", input.userId, {
             bypassCurrentMembershipCheck: input.bypassCurrentMembershipCheck,
           });
-    if (input.outcome !== "failed" && options.connectionIntentHeartbeat) {
-      await wakeConnectionIntentAfterResolution(options.connectionIntentHeartbeat, {
-        loaded,
-        status: interaction.status,
-        actorId: input.userId,
-      });
+    if (interaction.status === "accepted" && options.connectionIntentHeartbeat) {
+      await connectionIntentDeliveryService(db, options.connectionIntentHeartbeat).tryDeliver(input.interactionId);
     }
     return interaction;
   }
@@ -338,12 +327,17 @@ export function toolAccessRoutes(
       // interoperable spelling and retain the browser's exact origin as OAuth
       // state for popup postMessage below.
       if (
-        (options.deploymentMode ?? "local_trusted") === "local_trusted"
+        req.method !== "GET"
+        && req.method !== "HEAD"
+        && (options.deploymentMode ?? "local_trusted") === "local_trusted"
         && parsed.protocol === "http:"
         && parsed.hostname !== "localhost"
       ) {
         parsed.hostname = "localhost";
       }
+      // A provider callback has no initiating browser Origin. Preserve its
+      // actual host: rewriting 127.0.0.1 here changes the redirect_uri used at
+      // authorization and causes the token endpoint to reject the code.
       return parsed.origin;
     } catch {
       return null;
@@ -862,8 +856,9 @@ function connectorEnrollmentPrincipal(req: Request): string {
     // On resume, the persisted connection identity is authoritative: accepting
     // a contradictory `grantKind: "user"` here could otherwise let a creator
     // replace the credential behind an existing organization grant.
-    const resumedConnection = req.body.resumeConnectionId
-      ? await svc.getConnection(req.body.resumeConnectionId, companyId)
+    const retainedConnectionId = req.body.resumeConnectionId ?? req.body.reconnectConnectionId;
+    const resumedConnection = retainedConnectionId
+      ? await svc.getConnection(retainedConnectionId, companyId)
       : null;
     const effectiveGrantKind = resumedConnection
       ? resumedConnection.credentialPolicy === "per_user"

server/src/services/connection-intent-delivery.ts

@@ -0,0 +1,120 @@
+import { connectionIntentService } from "./connection-intents.js";
+import { and, eq, isNull, lte, asc, notInArray } from "drizzle-orm";
+import { connectionIntentDeliveries, issueThreadInteractions, issues, agentWakeupRequests, companyMemberships, type Db } from "@paperclipai/db";
+import type { heartbeatService } from "./heartbeat.js";
+type Heartbeat = ReturnType<typeof heartbeatService>;
+
+export async function wakeConnectionIntentAfterResolution(
+  heartbeat: Pick<Heartbeat, "wakeup">,
+  input: {
+    loaded: {
+      issue: { id: string; assigneeAgentId: string | null; status: string };
+      interaction: { id: string; resolvedAt?: string | Date | null };
+    };
+    status: string;
+    actorId: string;
+  },
+) {
+  const agentId = input.loaded.issue.assigneeAgentId;
+  if (!agentId || !["in_progress", "in_review"].includes(input.loaded.issue.status)) return;
+  const resolvedAt = input.loaded.interaction.resolvedAt;
+  const interactionResolvedAt = resolvedAt instanceof Date ? resolvedAt.toISOString() : resolvedAt;
+  await heartbeat.wakeup(agentId, {
+    source: "automation",
+    triggerDetail: "system",
+    reason: "issue_commented",
+    payload: {
+      issueId: input.loaded.issue.id,
+      interactionId: input.loaded.interaction.id,
+      interactionKind: "connection_intent",
+      interactionStatus: input.status,
+      mutation: "interaction",
+    },
+    idempotencyKey: `connection-intent:${input.loaded.interaction.id}:${input.status}`,
+    requestedByActorType: "user",
+    requestedByActorId: input.actorId,
+    contextSnapshot: {
+      issueId: input.loaded.issue.id,
+      taskId: input.loaded.issue.id,
+      interactionId: input.loaded.interaction.id,
+      interactionKind: "connection_intent",
+      interactionStatus: input.status,
+      mutation: "interaction",
+      wakeReason: "issue_commented",
+      source: "connection_intent.resolved",
+      ...(interactionResolvedAt
+        ? { interactionResolvedAt }
+        : {}),
+      forceFreshSession: true,
+    },
+    issueStateGuard: {
+      statuses: ["in_progress", "in_review"],
+      assigneeAgentId: agentId,
+    },
+  });
+}
+
+
+export function connectionIntentDeliveryService(db: Db, heartbeat: Pick<Heartbeat, "wakeup">) {
+  async function deliver(interactionId: string) {
+    // Deterministic acceptance-test failpoint: preserve committed outcomes across a server restart.
+    if (process.env.NODE_ENV === "test" && process.env.PAPERCLIP_TEST_CONNECTION_DELIVERY_HOLD === "1") return;
+    const now = new Date();
+    // The retry deadline is also the worker lease. A crashed worker is reclaimed.
+    const [claimed] = await db.update(connectionIntentDeliveries)
+      .set({ nextAttemptAt: new Date(now.getTime() + 60_000) })
+      .where(and(eq(connectionIntentDeliveries.interactionId, interactionId), isNull(connectionIntentDeliveries.deliveredAt), lte(connectionIntentDeliveries.nextAttemptAt, now))).returning();
+    if (!claimed) return;
+    const [loaded] = await db.select({ interaction: issueThreadInteractions, issue: issues })
+      .from(issueThreadInteractions).innerJoin(issues, eq(issues.id, issueThreadInteractions.issueId))
+      .where(and(eq(issueThreadInteractions.id, interactionId), eq(issueThreadInteractions.companyId, claimed.companyId), eq(issues.companyId, claimed.companyId)));
+    const interaction = loaded?.interaction;
+    const payload = interaction?.payload as { requestingAgentId?: string; serviceSlug?: string } | undefined;
+    if (!loaded || !interaction || !["accepted", "rejected"].includes(interaction.status)
+      || ["done", "cancelled"].includes(loaded.issue.status) || loaded.issue.assigneeAgentId !== payload?.requestingAgentId) {
+      await db.update(connectionIntentDeliveries).set({ deliveredAt: new Date() }).where(eq(connectionIntentDeliveries.interactionId, interactionId));
+      return;
+    }
+    const userId = interaction.addresseeUserId;
+    if (userId !== "local-board") {
+      const [membership] = await db.select().from(companyMemberships).where(and(
+        eq(companyMemberships.companyId, claimed.companyId), eq(companyMemberships.principalType, "user"),
+        eq(companyMemberships.principalId, userId ?? ""), eq(companyMemberships.status, "active"),
+      )).limit(1);
+      if (!membership?.membershipRole || membership.membershipRole === "viewer") {
+        await db.update(connectionIntentDeliveries).set({ deliveredAt: new Date() }).where(eq(connectionIntentDeliveries.interactionId, interactionId));
+        return;
+      }
+    }
+    if (interaction.status === "accepted") {
+      const ready = await connectionIntentService(db).usableConnectionForAgent({ companyId: claimed.companyId,
+        agentId: payload!.requestingAgentId!, responsibleUserId: userId!, serviceSlug: payload!.serviceSlug! });
+      if (!ready) return;
+    }
+    if (!["in_progress", "in_review"].includes(loaded.issue.status)) return;
+    const durableWake = () => db.select({ id: agentWakeupRequests.id }).from(agentWakeupRequests).where(and(
+      eq(agentWakeupRequests.companyId, claimed.companyId),
+      eq(agentWakeupRequests.idempotencyKey, `connection-intent:${interactionId}:${interaction.status}`),
+      notInArray(agentWakeupRequests.status, ["skipped", "failed", "cancelled"]),
+    )).limit(1);
+    // Check before dispatch: the previous worker may have crashed after enqueueing.
+    if (!(await durableWake()).length) {
+      try {
+        await wakeConnectionIntentAfterResolution(heartbeat, { loaded, status: interaction.status, actorId: interaction.resolvedByUserId ?? interaction.addresseeUserId! });
+      } catch (error) {
+        // The unique wake key also protects overlapping leases. Other failures retry.
+        if (!(await durableWake()).length) throw error;
+      }
+    }
+    if ((await durableWake()).length) {
+      await db.update(connectionIntentDeliveries).set({ deliveredAt: new Date() }).where(eq(connectionIntentDeliveries.interactionId, interactionId));
+    }
+  }
+  return { deliver, tryDeliver: async (id: string) => { try { await deliver(id); } catch { /* Persisted delivery remains due after its lease. */ } }, sweepPending: async () => {
+    const rows = await db.select().from(connectionIntentDeliveries).where(and(isNull(connectionIntentDeliveries.deliveredAt), lte(connectionIntentDeliveries.nextAttemptAt, new Date())))
+      .orderBy(asc(connectionIntentDeliveries.nextAttemptAt)).limit(50);
+    let failed = 0;
+    for (const row of rows) { try { await deliver(row.interactionId); } catch { failed += 1; } }
+    return { scanned: rows.length, failed };
+  }};
+}

server/src/services/connection-intents.ts

@@ -2,6 +2,8 @@ import { and, eq } from "drizzle-orm";
 import type { Db } from "@paperclipai/db";
 import {
   agents,
+  toolConnections,
+  toolCatalogEntries,
   companyMemberships,
   heartbeatRuns,
   issueThreadInteractions,
@@ -12,8 +14,9 @@ import {
   CONNECTABLE_APP_DEFINITIONS,
   connectionIntentPayloadSchema,
   getAvailableConnectionMethods,
+  isToolConnectionAttentionHealth,
+  type ConnectionSearchResultItem,
   getAppStoreDefinition,
-  getConnectableAppDefinition,
   type ConnectionIntentInteraction,
   type ConnectionIntentSetupOptions,
   type ConnectionRequestResult,
@@ -25,8 +28,11 @@ import { conflict, forbidden, notFound, unprocessable } from "../errors.js";
 import type { RuntimeToolsTokenClaims } from "../runtime-tools-token.js";
 import { issueThreadInteractionService } from "./issue-thread-interactions.js";
 import { toolAccessService } from "./tool-access.js";
+import { captureRunIdentity } from "./run-identity.js";
 import { resolveManagedGitHubIdentitySelection } from "./git-credentials.js";
 
+type ConnectionRunClaims = Pick<RuntimeToolsTokenClaims, "sub" | "company_id" | "run_id" | "responsible_user_id">;
+
 type DbTransaction = Parameters<Parameters<Db["transaction"]>[0]>[0];
 
 function record(value: unknown): Record<string, unknown> | null {
@@ -47,14 +53,12 @@ function sourceSlugForConnection(
   connection: ToolConnection,
   applications: ReadonlyMap<string, ToolApplication>,
 ) {
-  return text(connection.config?.sourceTemplateKey)
+  const source = text(connection.config?.sourceTemplateKey)
     ?? text(connection.transportConfig?.sourceTemplateKey)
     ?? sourceSlugForApplication(applications.get(connection.applicationId));
+  return source && getAppStoreDefinition(source) ? source : `connection:${connection.id}`;
 }
 
-function displayDescription(app: (typeof CONNECTABLE_APP_DEFINITIONS)[number]) {
-  return text(app.description) ?? null;
-}
 
 export function connectionIntentService(db: Db) {
   const interactions = issueThreadInteractionService(db);
@@ -118,8 +122,8 @@ export function connectionIntentService(db: Db) {
     }
   }
 
-  async function loadRunContext(claims: RuntimeToolsTokenClaims) {
-    const run = await db
+  async function loadRunContext(claims: ConnectionRunClaims) {
+    let run = await db
       .select({
         id: heartbeatRuns.id,
         companyId: heartbeatRuns.companyId,
@@ -139,6 +143,11 @@ export function connectionIntentService(db: Db) {
       || (!run.activeIdentityContextId && run.responsibleUserId !== claims.responsible_user_id)
     ) throw forbidden("Runtime tool token does not match its heartbeat run");
     if (run.status !== "running") throw forbidden("Runtime tool token is no longer active");
+    if (run.activeIdentityContextId) {
+      const current = await captureRunIdentity(db, { companyId: run.companyId, agentId: run.agentId, runId: run.id });
+      run = { ...run, responsibleUserId: current.run.responsibleUserId };
+    }
+    if (!run.responsibleUserId) throw forbidden("This task needs a responsible user to connect a service");
     const snapshot = record(run.contextSnapshot);
     const issueId = text(snapshot?.issueId) ?? text(snapshot?.taskId);
     if (!issueId) throw unprocessable("Connection requests require a task-bound heartbeat run");
@@ -171,6 +180,7 @@ export function connectionIntentService(db: Db) {
     ) {
       throw forbidden("Responsible user is no longer authorized for company write access");
     }
+    if (issue.assigneeAgentId !== agent.id) throw conflict("The requesting agent no longer owns this task");
     if (issue.status === "done" || issue.status === "cancelled") {
       throw conflict("Connection requests cannot be created on a closed task");
     }
@@ -199,21 +209,23 @@ export function connectionIntentService(db: Db) {
     const inventory = input.inventory ?? await connectionInventory(input.companyId);
     const matching = inventory.connections.filter((connection) =>
       sourceSlugForConnection(connection, inventory.applicationsById) === input.serviceSlug
-      && connection.status === "active"
-      && connection.enabled
+      && connection.status !== "archived"
     );
     if (matching.length === 0) return null;
-    if (input.serviceSlug === "github") {
-      const selection = await resolveManagedGitHubIdentitySelection(db, input.companyId, {
-        agentId: input.agentId,
-        responsibleUserId: input.responsibleUserId,
-      });
-      return selection.grant
-        ? matching.find((connection) => connection.id === selection.grant!.connectionId) ?? null
-        : null;
-    }
     const effective = await access.getEffectiveProfilesForAgent(input.companyId, input.agentId);
     const installedIds = new Set(effective.installedConnections.map((connection) => connection.id));
+    const permittedIds = new Set(effective.allowedTools.map((tool) => tool.connectionId));
+    const usable = (connection: ToolConnection | undefined) => connection
+      && installedIds.has(connection.id) && permittedIds.has(connection.id)
+      && connection.status === "active" && connection.enabled
+      && ["mcp_remote", "local_stdio"].includes(connection.transport)
+      && !isToolConnectionAttentionHealth(connection.healthStatus) ? connection : null;
+    if (input.serviceSlug === "github") {
+      const selection = await resolveManagedGitHubIdentitySelection(db, input.companyId, {
+        agentId: input.agentId, responsibleUserId: input.responsibleUserId,
+      });
+      return usable(matching.find((connection) => connection.id === selection.grant?.connectionId));
+    }
     const installed = matching.filter((connection) => installedIds.has(connection.id));
     const grantsByConnection = await Promise.all(installed.map(async (connection) => ({
       connection,
@@ -228,7 +240,7 @@ export function connectionIntentService(db: Db) {
       .map((grant) => ({ connection, grant })));
     if (dedicated.length > 0) {
       const active = dedicated.filter(({ grant }) => grant.status === "active");
-      return active.length === 1 ? active[0]!.connection : null;
+      return active.length === 1 ? usable(active[0]!.connection) : null;
     }
 
     const personal = grantsByConnection.flatMap(({ connection, grants }) => grants
@@ -236,68 +248,121 @@ export function connectionIntentService(db: Db) {
       .map((grant) => ({ connection, grant })));
     if (personal.length > 0) {
       const active = personal.filter(({ grant }) => grant.status === "active");
-      return active.length === 1 ? active[0]!.connection : null;
+      return active.length === 1 ? usable(active[0]!.connection) : null;
     }
 
     const organization = grantsByConnection.flatMap(({ connection, grants }) => grants
       .filter((grant) => grant.kind === "organization")
       .map((grant) => ({ connection, grant })));
     const activeOrganization = organization.filter(({ grant }) => grant.status === "active");
-    return activeOrganization.length === 1 ? activeOrganization[0]!.connection : null;
+    return activeOrganization.length === 1 ? usable(activeOrganization[0]!.connection) : null;
   }
 
-  async function search(claims: RuntimeToolsTokenClaims, query: string): Promise<ConnectionsSearchResult> {
+  async function administrativeDenial(companyId: string, agentId: string, serviceSlug: string, inventory: Awaited<ReturnType<typeof connectionInventory>>) {
+    const effective = await access.getEffectiveProfilesForAgent(companyId, agentId);
+    const installed = effective.installedConnections.filter((connection) => sourceSlugForConnection(connection, inventory.applicationsById) === serviceSlug);
+    if (!installed.length || effective.allowedTools.some((tool) => installed.some((connection) => connection.id === tool.connectionId))) return false;
+    for (const connection of installed) {
+      if ((await indexedCatalog(connection.id, companyId)).some((tool) => tool.entryKind === "tool")) return true;
+    }
+    return false;
+  }
+
+  function indexedCatalog(connectionId: string, companyId: string) {
+    // Discovery must not contact providers or mutate their health/cache state.
+    return db.select().from(toolCatalogEntries).where(and(
+      eq(toolCatalogEntries.companyId, companyId), eq(toolCatalogEntries.connectionId, connectionId),
+      eq(toolCatalogEntries.status, "active"),
+    ));
+  }
+
+  async function resolveService(service: string, companyId: string, userId: string, agentId: string) {
+    if (!service.startsWith("connection:")) {
+      const app = getAppStoreDefinition(service);
+      if (!app) throw notFound("Connection service was not found");
+      return { ...app, available: app.availability?.available !== false,
+        searchCapabilities: getAvailableConnectionMethods(app).map((method) =>
+          `${method.whenToUse} ${method.capabilityProfile?.label ?? ""} ${method.capabilityProfile?.description ?? ""}`).join(" "),
+        methods: getAvailableConnectionMethods(app).map((method) => ({
+          key: method.key, label: method.label ?? method.key, auth: method.auth,
+        })), source: "catalog" as const };
+    }
+    const id = service.slice("connection:".length);
+    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id)) {
+      throw notFound("Configured connection was not found");
+    }
+    const connection = await access.getConnection(id, companyId);
+    const { grants } = await access.listConnectionGrants(id, companyId);
+    if (connection.status === "archived" || !grants.some((grant) => grant.status === "active" && (
+      grant.kind === "organization" || (grant.kind === "user" && grant.subjectUserId === userId)
+      || (grant.kind === "agent" && grant.subjectAgentId === agentId)
+    ))) throw notFound("Configured connection was not found");
+    const application = await access.getApplication(connection.applicationId, companyId);
+    return {
+      slug: service, name: connection.name, description: application.description, searchCapabilities: "",
+      branding: { logoUrl: undefined, darkLogoUrl: undefined },
+      available: connection.enabled,
+      methods: [{ key: "configured", label: "Use configured connection", auth:
+        connection.authKind === "oauth" ? "oauth" as const : connection.authKind === "none" ? "none" as const : "api_key" as const }],
+      source: "configured" as const,
+    };
+  }
+
+  async function search(claims: ConnectionRunClaims, query: string): Promise<ConnectionsSearchResult> {
     const { run, agent } = await loadRunContext(claims);
     const normalized = query.trim().toLocaleLowerCase();
+    const tokens = normalized.split(/[^\p{L}\p{N}]+/u).filter(Boolean);
     const inventory = await connectionInventory(run.companyId);
-    const results = await Promise.all(APP_STORE_DEFINITIONS
-      .filter((app) => !normalized
-        || app.slug.toLocaleLowerCase().includes(normalized)
-        || app.name.toLocaleLowerCase().includes(normalized)
-        || displayDescription(app)?.toLocaleLowerCase().includes(normalized))
-      .map(async (app) => {
-        const methods = getAvailableConnectionMethods(app);
-        const matching = inventory.connections.filter((connection) =>
-          sourceSlugForConnection(connection, inventory.applicationsById) === app.slug
-          && connection.status !== "archived"
-        );
-        const ready = await usableConnectionForAgent({
-          companyId: run.companyId,
-          agentId: agent.id,
-          responsibleUserId: run.responsibleUserId!,
-          serviceSlug: app.slug,
-          inventory,
-        });
-        return {
-          service: app.slug,
-          name: app.name,
-          description: displayDescription(app),
-          logoUrl: app.branding.logoUrl ?? null,
-          methods: methods.map((method) => ({
-            key: method.key,
-            label: method.label ?? method.key,
-            auth: method.auth,
-          })),
-          state: app.availability?.available === false || methods.length === 0
-            ? "unavailable" as const
-            : ready
-              ? "ready" as const
-              : matching.length > 0
-                ? "needs_user_action" as const
-                : "available" as const,
-          connectionId: ready?.id ?? null,
-        };
+    const candidates: Array<{ item: ConnectionSearchResultItem; score: number }> = [];
+    const services = [...APP_STORE_DEFINITIONS.map((app) => app.slug),
+      ...inventory.connections.filter((connection) =>
+        sourceSlugForConnection(connection, inventory.applicationsById)?.startsWith("connection:")
+        && connection.status !== "archived").map((connection) => `connection:${connection.id}`)];
+    for (const service of services) {
+      let app;
+      try { app = await resolveService(service, run.companyId, run.responsibleUserId!, agent.id); }
+      catch (error) { if (service.startsWith("connection:") && (error as { status?: number }).status === 404) continue; throw error; }
+      const matching = inventory.connections.filter((connection) =>
+        sourceSlugForConnection(connection, inventory.applicationsById) === service && connection.status !== "archived");
+      // Indexed descriptions can contain private workspace metadata, including
+      // for catalog providers. Check each configured connection's audience first.
+      const catalogs = await Promise.all(matching.map(async (connection) => {
+        const { grants } = await access.listConnectionGrants(connection.id, run.companyId);
+        const authorized = grants.some((grant) => grant.status === "active" && (
+          grant.kind === "organization" || (grant.kind === "user" && grant.subjectUserId === run.responsibleUserId)
+          || (grant.kind === "agent" && grant.subjectAgentId === agent.id)
+        ));
+        return authorized ? indexedCatalog(connection.id, run.companyId) : [];
       }));
-    return { version: 1, query, results };
+      const catalog = catalogs.flat().filter((entry) => entry.status === "active");
+      const haystack = `${app.slug} ${app.name} ${app.description ?? ""} ${app.searchCapabilities} ${catalog.map((tool) => `${tool.toolName} ${tool.description ?? ""}`).join(" ")}`.toLocaleLowerCase();
+      const score = !normalized ? 1 : app.slug === normalized || app.name.toLocaleLowerCase() === normalized
+        ? 1000 : tokens.reduce((sum, token) => sum + (haystack.includes(token) ? 1 : 0), 0);
+      if (!score) continue;
+      const ready = await usableConnectionForAgent({ companyId: run.companyId, agentId: agent.id,
+        responsibleUserId: run.responsibleUserId!, serviceSlug: service, inventory });
+      const denied = !ready && matching.length > 0 && await administrativeDenial(run.companyId, agent.id, service, inventory);
+      candidates.push({ score, item: {
+        service, name: app.name, description: app.description ?? null, logoUrl: app.branding.logoUrl ?? null,
+        methods: app.methods, source: app.source,
+        state: ready ? "ready" : denied ? "unavailable" : !app.available || !app.methods.length ? "unavailable"
+          : matching.length ? "needs_user_action" : "available",
+        reason: ready ? "Connection is installed and usable by this agent" : denied ? "An administrator has not permitted executable tools for this agent; reconnecting cannot grant that permission" : !app.available ? "Connection is disabled or unavailable"
+          : matching.some((connection) => isToolConnectionAttentionHealth(connection.healthStatus)) ? "Connection needs attention"
+          : matching.length ? "Review identity and access for this agent" : "Connect this service to continue",
+        connectionId: ready?.id ?? null,
+      }});
+    }
+    return { version: 1, query, results: candidates.sort((a, b) => b.score - a.score || a.item.name.localeCompare(b.item.name)).slice(0, 20).map(({ item }) => item) };
   }
 
   async function request(
-    claims: RuntimeToolsTokenClaims,
+    claims: ConnectionRunClaims,
     serviceSlug: string,
   ): Promise<ConnectionRequestResult> {
     const context = await loadRunContext(claims);
-    const app = getAppStoreDefinition(serviceSlug);
-    if (!app || app.availability?.available === false || getAvailableConnectionMethods(app).length === 0) {
+    const app = await resolveService(serviceSlug, context.run.companyId, context.run.responsibleUserId!, context.agent.id);
+    if (!app.available || app.methods.length === 0) {
       throw unprocessable(`Connection service ${serviceSlug} is not available`);
     }
     const ready = await usableConnectionForAgent({
@@ -313,9 +378,19 @@ export function connectionIntentService(db: Db) {
         state: "ready",
         connectionId: ready.id,
         interactionId: null,
-        instruction: `${app.name} is connected and available in this run.`,
+        instruction: `${app.name} is connected. Use its installed tools; a native continuation will refresh tools if needed.`,
       };
     }
+    if (await administrativeDenial(context.run.companyId, context.agent.id, app.slug, await connectionInventory(context.run.companyId))) {
+      throw forbidden("This agent has no permitted actions for this service. Ask an administrator to review tool permissions; reconnecting will not remove a denial.");
+    }
+    const outcomeId = context.run.contextSnapshot?.interactionId;
+    if (typeof outcomeId === "string") {
+      const [outcome] = await db.select().from(issueThreadInteractions).where(and(eq(issueThreadInteractions.id, outcomeId), eq(issueThreadInteractions.companyId, context.run.companyId), eq(issueThreadInteractions.issueId, context.issue.id)));
+      if (outcome?.kind === "connection_intent" && outcome.status === "rejected" && connectionIntentPayloadSchema.parse(outcome.payload).serviceSlug === app.slug) {
+        throw conflict("The user declined this connection. Pursue alternatives; do not request it again in this continuation.");
+      }
+    }
     const interaction = await interactions.createConnectionIntent(
       context.issue,
       {
@@ -330,17 +405,19 @@ export function connectionIntentService(db: Db) {
           phase: "requested",
         },
         sourceRunId: context.run.id,
+        sourceIdentityContextId: context.run.activeIdentityContextId,
         addresseeUserId: context.run.responsibleUserId!,
-        idempotencyKey: `connection-intent:${context.run.id}:${app.slug}`,
+        idempotencyKey: `connection-intent:${context.run.id}:${context.run.responsibleUserId}:${app.slug}`,
       },
     );
+    if (interaction.status !== "pending") throw conflict("This connection request has already been resolved. Follow its recorded outcome.");
     return {
       version: 1,
       service: app.slug,
       state: "needs_user_action",
       connectionId: null,
       interactionId: interaction.id,
-      instruction: `A connection card was sent to the responsible user. End this run and wait for continuation.`,
+      instruction: `A connection card was sent to the responsible user. Finish independent work, then yield and wait for continuation. Do not repeat this request.`,
     };
   }
 
@@ -359,8 +436,7 @@ export function connectionIntentService(db: Db) {
   async function setupOptions(interactionId: string): Promise<ConnectionIntentSetupOptions> {
     const loaded = await loadIntent(interactionId);
     const payload = connectionIntentPayloadSchema.parse(loaded.interaction.payload);
-    const app = getConnectableAppDefinition(payload.serviceSlug);
-    if (!app) throw notFound("Connection service is no longer available");
+    const app = await resolveService(payload.serviceSlug, loaded.issue.companyId, loaded.interaction.addresseeUserId!, payload.requestingAgentId);
     const inventory = await connectionInventory(loaded.issue.companyId);
     const matchingConnections = inventory.connections.filter((connection) =>
       sourceSlugForConnection(connection, inventory.applicationsById) === app.slug
@@ -371,7 +447,8 @@ export function connectionIntentService(db: Db) {
       const { grants } = await access.listConnectionGrants(connection.id, loaded.issue.companyId);
       const eligible = grants.some((grant) =>
         grant.status === "active"
-        && (grant.kind === "organization" || grant.subjectUserId === loaded.interaction.addresseeUserId)
+        && (grant.kind === "organization" || grant.subjectUserId === loaded.interaction.addresseeUserId
+          || (grant.kind === "agent" && grant.subjectAgentId === payload.requestingAgentId))
       );
       return eligible ? connection : null;
     }))).filter((connection): connection is ToolConnection => connection !== null);
@@ -381,17 +458,16 @@ export function connectionIntentService(db: Db) {
       service: {
         service: app.slug,
         name: app.name,
-        description: displayDescription(app),
+        description: app.description ?? null,
         logoUrl: app.branding.logoUrl ?? null,
-        methods: getAvailableConnectionMethods(app).map((method) => ({
-          key: method.key,
-          label: method.label ?? method.key,
-          auth: method.auth,
-        })),
+        methods: app.methods,
+        source: app.source,
         state: existingConnections.length > 0 ? "needs_user_action" : "available",
         connectionId: null,
       },
-      existingConnections,
+      existingConnections: existingConnections.map(({ id, applicationId, name, status, enabled }) => ({
+        id, applicationId, name, status, enabled,
+      })),
       requestedAgentId: payload.requestingAgentId,
     };
   }
@@ -406,7 +482,10 @@ export function connectionIntentService(db: Db) {
     } = {},
   ) {
     const loaded = await loadIntent(interactionId);
-    if (loaded.interaction.status !== "pending") throw conflict("Connection intent is already resolved");
+    if (loaded.interaction.status !== "pending") {
+      if (loaded.interaction.status === "accepted" && loaded.interaction.result?.connectionId === connectionId && loaded.interaction.addresseeUserId === userId) return loaded.interaction;
+      throw conflict("Connection intent is already resolved");
+    }
     if (loaded.interaction.addresseeUserId !== userId) throw forbidden("Only the addressed user can connect this service");
     await assertCurrentUserWriteAccess(
       loaded.issue.companyId,
@@ -415,6 +494,8 @@ export function connectionIntentService(db: Db) {
     );
     const payload = connectionIntentPayloadSchema.parse(loaded.interaction.payload);
     return db.transaction(async (tx) => {
+      const [task] = await tx.select().from(issues).where(and(eq(issues.id, loaded.issue.id), eq(issues.companyId, loaded.issue.companyId))).for("update");
+      if (!task || task.assigneeAgentId !== payload.requestingAgentId || ["done", "cancelled"].includes(task.status)) throw conflict("Connection request no longer belongs to an active task");
       // Membership downgrade/removal takes the same row lock. Whichever side
       // commits first is authoritative: a completed revocation makes this
       // revalidation fail, while completion holds authority through OAuth
@@ -428,6 +509,7 @@ export function connectionIntentService(db: Db) {
       const txDb = tx as unknown as Db;
       const txAccess = toolAccessService(txDb);
       const txInteractions = issueThreadInteractionService(txDb);
+      await tx.select({ id: toolConnections.id }).from(toolConnections).where(and(eq(toolConnections.id, connectionId), eq(toolConnections.companyId, loaded.issue.companyId))).for("update");
       let selectedConnection = await txAccess.getConnection(connectionId, loaded.issue.companyId);
       const selectedApplication = await txAccess.getApplication(
         selectedConnection.applicationId,
@@ -439,7 +521,7 @@ export function connectionIntentService(db: Db) {
       ) !== payload.serviceSlug) {
         throw notFound("Connection does not match this intent");
       }
-      if (selectedConnection.status !== "active" || !selectedConnection.enabled) {
+      if (selectedConnection.status !== "active" || !selectedConnection.enabled || isToolConnectionAttentionHealth(selectedConnection.healthStatus)) {
         throw conflict("Finish and test this connection before using it for the task");
       }
 
@@ -452,13 +534,14 @@ export function connectionIntentService(db: Db) {
       );
       if (selectedConnection.authKind === "oauth" && pendingPersonalGrant) {
         // txAccess is bound to the outer transaction. Its internal transactions
-        // become savepoints, so activation, credential bindings, the all-agents
-        // profile, and the company install roll back with any later failure.
+        // become savepoints, so activation, credential bindings, and the
+        // requesting agent's access roll back with any later failure.
         await txAccess.finalizeOAuthAccess(
           loaded.issue.companyId,
           selectedConnection.id,
           { grantKind: "user" },
           { actorType: "user", actorId: userId },
+          payload.requestingAgentId,
         );
         selectedConnection = await txAccess.getConnection(
           selectedConnection.id,
@@ -475,10 +558,11 @@ export function connectionIntentService(db: Db) {
       const organizationGrant = grants.find((grant) =>
         grant.kind === "organization" && grant.status === "active"
       );
-      if (!personalGrant && !organizationGrant) {
+      const dedicatedGrant = grants.find((grant) => grant.kind === "agent" && grant.status === "active" && grant.subjectAgentId === payload.requestingAgentId);
+      if (!personalGrant && !organizationGrant && !dedicatedGrant) {
         throw conflict("This connection has no usable identity grant");
       }
-      if (!personalGrant && !options.canManageOrganizationGrant) {
+      if (!personalGrant && !dedicatedGrant && !options.canManageOrganizationGrant) {
         throw forbidden("Sharing a company connection requires connection-management authority");
       }
 
@@ -504,6 +588,15 @@ export function connectionIntentService(db: Db) {
         actorId: userId,
       });
 
+      const effective = await txAccess.getEffectiveProfilesForAgent(loaded.issue.companyId, payload.requestingAgentId);
+      if (!effective.allowedTools.some((tool) => tool.connectionId === selectedConnection.id)) throw conflict("This connection has no permitted tools. Review its action permissions before continuing.");
+
+      const runtimeConnection = await connectionIntentService(txDb).usableConnectionForAgent({
+        companyId: loaded.issue.companyId, agentId: payload.requestingAgentId,
+        responsibleUserId: userId, serviceSlug: payload.serviceSlug,
+      });
+      if (runtimeConnection?.id !== selectedConnection.id) throw conflict("This identity is not the connection this agent can execute. Resolve conflicting identities before continuing.");
+
       return txInteractions.resolveConnectionIntent(
         loaded.issue,
         interactionId,
@@ -536,6 +629,7 @@ export function connectionIntentService(db: Db) {
 
   return {
     validate: loadRunContext,
+    usableConnectionForAgent,
     search,
     request,
     loadIntent,

server/src/services/connection-tool-definitions.ts

@@ -0,0 +1,24 @@
+import { CONNECTION_REQUEST_TOOL_DESCRIPTION, CONNECTIONS_SEARCH_TOOL_DESCRIPTION } from "@paperclipai/shared";
+
+export const RUNTIME_CONNECTION_TOOL_DEFINITIONS = [
+  {
+    name: "connections_search",
+    description: CONNECTIONS_SEARCH_TOOL_DESCRIPTION,
+    inputSchema: {
+      type: "object",
+      properties: { query: { type: "string" } },
+      additionalProperties: false,
+    },
+  },
+  {
+    name: "connection_request",
+    description: CONNECTION_REQUEST_TOOL_DESCRIPTION,
+    inputSchema: {
+      type: "object",
+      properties: { service: { type: "string" } },
+      required: ["service"],
+      additionalProperties: false,
+    },
+  },
+] as const;
+

server/src/services/heartbeat.ts

@@ -17462,11 +17462,12 @@ export function heartbeatService(
         isResolvedInteractionContinuationWakeContext(context)
       ) {
         try {
-          // Claim the issue under the same in_progress predicate used by the
+          // Claim the issue under the same active-status predicate used by the
           // queued-run staleness gate. This is the final atomic guard before
           // dispatch: an operator parking the issue after claim but before this
           // checkout must not be overwritten by the continuation.
-          await issuesSvc.checkout(issueId, agent.id, ["in_progress"], run.id);
+          await issuesSvc.checkout(issueId, agent.id, context.interactionKind === "connection_intent"
+            ? ["in_progress", "in_review"] : ["in_progress"], run.id);
           context[PAPERCLIP_HARNESS_CHECKOUT_KEY] = true;
         } catch (error) {
           if (!isCheckoutConflictError(error)) throw error;

server/src/services/issue-thread-interactions.ts

@@ -1,3 +1,4 @@
+import { connectionIntentDeliveries } from "@paperclipai/db";
 import { isDeepStrictEqual } from "node:util";
 import { and, asc, desc, eq, inArray, isNotNull, isNull, ne } from "drizzle-orm";
 import type { Db } from "@paperclipai/db";
@@ -656,7 +657,7 @@ function shouldReturnAcceptedConfirmationToCreatorAgent(args: {
 }
 
 function shouldSupersedeInteractionOnUserComment(interaction: UserCommentSupersedableInteraction) {
-  if (interaction.kind === "connection_intent") return true;
+  if (interaction.kind === "connection_intent") return false;
   return interaction.payload.supersedeOnUserComment === true;
 }
 
@@ -2034,6 +2035,7 @@ export function issueThreadInteractionService(db: Db, opts: IssueThreadInteracti
       input: {
         payload: ConnectionIntentInteraction["payload"];
         sourceRunId: string;
+        sourceIdentityContextId?: string | null;
         addresseeUserId: string;
         idempotencyKey: string;
       },
@@ -2049,7 +2051,9 @@ export function issueThreadInteractionService(db: Db, opts: IssueThreadInteracti
           existing.kind !== "connection_intent"
           || existing.sourceRunId !== input.sourceRunId
           || existing.addresseeUserId !== input.addresseeUserId
-          || !isDeepStrictEqual(existing.payload, payload)
+          || (existing.kind === "connection_intent"
+            ? connectionIntentPayloadSchema.parse(existing.payload).serviceSlug !== payload.serviceSlug
+            : !isDeepStrictEqual(existing.payload, payload))
         ) {
           throw conflict("Interaction idempotency key already exists for a different request", {
             idempotencyKey: input.idempotencyKey,
@@ -2058,17 +2062,31 @@ export function issueThreadInteractionService(db: Db, opts: IssueThreadInteracti
         return hydrateInteraction(existing) as ConnectionIntentInteraction;
       }
 
+      let inserted = false;
       const created = await db.transaction(async (tx) => {
         const issueRow = await tx
-          .select({ status: issues.status })
+          .select({ status: issues.status, assigneeAgentId: issues.assigneeAgentId })
           .from(issues)
           .where(and(eq(issues.id, issue.id), eq(issues.companyId, issue.companyId)))
           .for("update")
           .then((rows) => rows[0] ?? null);
-        if (!issueRow || isTerminalIssueStatus(issueRow.status)) {
+        if (!issueRow || isTerminalIssueStatus(issueRow.status) || issueRow.assigneeAgentId !== payload.requestingAgentId) {
           throw conflict("Cannot create an interaction on a closed issue");
         }
 
+        // Serialize on the task so retries and later runs share the same live card.
+        const pending = await tx.select().from(issueThreadInteractions).where(and(
+          eq(issueThreadInteractions.companyId, issue.companyId),
+          eq(issueThreadInteractions.issueId, issue.id),
+          eq(issueThreadInteractions.kind, "connection_intent"),
+          eq(issueThreadInteractions.status, "pending"),
+          eq(issueThreadInteractions.createdByAgentId, payload.requestingAgentId),
+          eq(issueThreadInteractions.addresseeUserId, input.addresseeUserId),
+        ));
+        const reusable = pending.find((candidate) =>
+          connectionIntentPayloadSchema.parse(candidate.payload).serviceSlug === payload.serviceSlug);
+        if (reusable) return reusable;
+
         const [row] = await tx
           .insert(issueThreadInteractions)
           .values({
@@ -2083,6 +2101,7 @@ export function issueThreadInteractionService(db: Db, opts: IssueThreadInteracti
             effectiveResolverPolicySource: "governed_action",
             idempotencyKey: input.idempotencyKey,
             sourceRunId: input.sourceRunId,
+            sourceIdentityContextId: input.sourceIdentityContextId ?? null,
             title: `Connect ${payload.serviceName}`,
             summary: `${payload.requestingAgentName} needs this connection to continue.`,
             createdByAgentId: payload.requestingAgentId,
@@ -2127,11 +2146,12 @@ export function issueThreadInteractionService(db: Db, opts: IssueThreadInteracti
             .where(inArray(issueThreadInteractions.id, supersededIds));
         }
         await touchIssue(tx, issue.id);
+        inserted = true;
         return row;
       });
 
       const interaction = hydrateInteraction(created) as ConnectionIntentInteraction;
-      emitInteractionCreatedTelemetry({
+      if (inserted) emitInteractionCreatedTelemetry({
         interactionKind: "connection_intent",
         usedDeprecatedResolverPolicyAlias: false,
       });
@@ -2182,7 +2202,8 @@ export function issueThreadInteractionService(db: Db, opts: IssueThreadInteracti
           ? "rejected"
           : "expired";
       const resolvedAt = now();
-      const [updated] = await db
+      const updated = await db.transaction(async (tx) => {
+        const [row] = await tx
         .update(issueThreadInteractions)
         .set({
           status,
@@ -2198,6 +2219,12 @@ export function issueThreadInteractionService(db: Db, opts: IssueThreadInteracti
           eq(issueThreadInteractions.status, "pending"),
         ))
         .returning();
+        if (!row) throw interactionAlreadyResolvedError();
+        if (status === "accepted" || status === "rejected") {
+          await tx.insert(connectionIntentDeliveries).values({ interactionId, companyId: issue.companyId }).onConflictDoNothing();
+        }
+        return row;
+      });
       if (!updated) throw interactionAlreadyResolvedError();
       await touchIssue(db, issue.id);
       const interaction = hydrateInteraction(updated) as ConnectionIntentInteraction;
@@ -3573,6 +3600,15 @@ export function issueThreadInteractionService(db: Db, opts: IssueThreadInteracti
       return expired;
     },
 
+    expireConnectionIntentsForOwnershipChange: async (issue: { id: string; companyId: string }) => {
+      const expired = await db.update(issueThreadInteractions).set({
+        status: "expired", result: { version: 1, outcome: "expired", reason: "The task assignment changed" },
+        resolvedAt: now(), updatedAt: now(),
+      }).where(and(eq(issueThreadInteractions.companyId, issue.companyId), eq(issueThreadInteractions.issueId, issue.id),
+        eq(issueThreadInteractions.kind, "connection_intent"), eq(issueThreadInteractions.status, "pending"))).returning();
+      if (expired.length) await db.delete(toolOauthStates).where(inArray(toolOauthStates.interactionId, expired.map((row) => row.id)));
+      return expired;
+    },
     expirePendingInteractionsForTerminalIssue: async (
       issue: { id: string; companyId: string; status: string },
       actor: InteractionActor = {},

server/src/services/issues.ts

@@ -7981,6 +7981,10 @@ export function issueService(db: Db) {
           .returning()
           .then((rows: Array<typeof issues.$inferSelect>) => rows[0] ?? null);
         if (!updated) return null;
+        if (updated.assigneeAgentId !== existing.assigneeAgentId || updated.assigneeUserId !== existing.assigneeUserId) {
+          const { issueThreadInteractionService } = await import("./issue-thread-interactions.js");
+          await issueThreadInteractionService(tx).expireConnectionIntentsForOwnershipChange(updated);
+        }
         if (existing.status !== updated.status) {
           if (
             (existing.status === "done" || existing.status === "cancelled")

server/src/services/native-runtime/native-interaction-bridge.ts

@@ -279,7 +279,7 @@ export async function materializeNativeInteractionResponses(input: {
       continue;
     }
 
-    if (interaction.kind === "suggest_tasks") {
+    if (interaction.kind === "suggest_tasks" || interaction.kind === "connection_intent") {
       if (
         (interaction.status !== "accepted" && interaction.status !== "rejected")
         || !interaction.result

server/src/services/native-runtime/native-session-executor.test.ts

@@ -180,6 +180,7 @@ import {
   nativeSessionFailureSourceCode,
   nativeSessionRecoveryProjection,
   nativeGovernedWaitResult,
+  nativeToolsRefreshWaitResult,
   parseRemoteExecutableCandidate,
   buildRemoteCodexLauncherCommand,
   mayUsePreinstalledRunnerArtifact,
@@ -2176,6 +2177,15 @@ describe("provider plan synchronization", () => {
 });
 
 describe("native governed waits", () => {
+  it("yields to an existing tools-refresh wake without claiming completion or a human interaction", () => {
+    const result = nativeToolsRefreshWaitResult({ wakeId: "wake-1", key: "connection-intent:tools:run-1:digest",
+      completionContract: { revision: "4", objective: "Read the archive", criteria: [{ id: "read", requirement: "Read the archive" }] } });
+    expect(result.completionClaim).toMatchObject({ contractRevision: "4", objectiveSatisfied: false });
+    expect(result.artifacts).toEqual([]);
+    expect(result.continuation).toMatchObject({ kind: "same_agent", idempotencyKey: "connection-intent:tools:run-1:digest" });
+    expect(result.evidence).toEqual([{ ref: "wakeup:wake-1" }]);
+  });
+
   it("turns a durable pending interaction into a response-wake result", () => {
     expect(
       nativeGovernedWaitResult({

server/src/services/native-runtime/native-session-executor.ts

@@ -56,8 +56,9 @@ import {
   type PaperclipRunnerTransport,
 } from "@paperclipai/adapter-utils/runner-connectivity";
 import type { Db } from "@paperclipai/db";
-import { and, desc, eq, gt, inArray, or, sql } from "drizzle-orm";
+import { and, desc, eq, gt, inArray, like, notInArray, or, sql } from "drizzle-orm";
 import {
+  agentWakeupRequests,
   documentRevisions,
   environmentLeases,
   heartbeatRunEvents,
@@ -885,6 +886,22 @@ export function createGovernedWaitEventObservation(
   };
 }
 
+export function nativeToolsRefreshWaitResult(input: {
+  wakeId: string; key: string;
+  completionContract: NativeExecutionInput["completionContract"]["contract"];
+}): PrpStructuredRunResult {
+  const ref = `wakeup:${input.wakeId}`;
+  return {
+    schema: "paperclip.run_result.v1", reportedWorkDisposition: "yielded",
+    summary: "Continuing with the newly installed connection tools.",
+    completionClaim: { contractRevision: input.completionContract.revision, objectiveSatisfied: false,
+      criteria: input.completionContract.criteria.map((criterion) => ({ criterionId: criterion.id, status: "unknown", evidenceRefs: [ref] })),
+      remainingWork: [{ description: "Continue in the queued session with updated tools.", blocksCompletion: true }] },
+    evidence: [{ ref }], verification: [], attentionRequests: [], artifacts: [],
+    continuation: { kind: "same_agent", summary: "Use the updated connection tools in a fresh session.", idempotencyKey: input.key },
+  };
+}
+
 /**
  * Partial item-verdict responses deliberately leave their original durable
  * interaction pending. They are already authority-checked before entering the
@@ -4343,6 +4360,10 @@ async function executePaperclipNativeSessionWithinScope(
               issueThreadInteractions.sourceRunId,
               input.execution.binding.runId,
             ),
+            and(
+              eq(issueThreadInteractions.kind, "connection_intent"),
+              eq(issueThreadInteractions.createdByAgentId, input.execution.binding.agentId),
+            ),
             ...(continuingInteractionIds.length > 0
               ? [inArray(issueThreadInteractions.id, continuingInteractionIds)]
               : []),
@@ -4356,12 +4377,20 @@ async function executePaperclipNativeSessionWithinScope(
       )
       .limit(1)
       .then((rows) => rows[0] ?? null);
-    return interaction
-      ? nativeGovernedWaitResult({
-          interaction,
-          completionContract: input.execution.completionContract.contract,
-        })
-      : null;
+    if (interaction) return nativeGovernedWaitResult({
+      interaction, completionContract: input.execution.completionContract.contract,
+    });
+    // A ready connection can become installed after the provider snapshot was
+    // pinned. Its already-durable wake is also a valid reason to end this turn.
+    const [refresh] = await input.db.select({ id: agentWakeupRequests.id, key: agentWakeupRequests.idempotencyKey })
+      .from(agentWakeupRequests).where(and(
+        eq(agentWakeupRequests.companyId, input.execution.binding.companyId),
+        eq(agentWakeupRequests.agentId, input.execution.binding.agentId),
+        like(agentWakeupRequests.idempotencyKey, `connection-intent:tools:${input.execution.binding.runId}:%`),
+        notInArray(agentWakeupRequests.status, ["skipped", "failed", "cancelled"]),
+      )).limit(1);
+    return refresh?.key ? nativeToolsRefreshWaitResult({ wakeId: refresh.id, key: refresh.key,
+      completionContract: input.execution.completionContract.contract }) : null;
   }
   const runnerExecution =
     input.useRunnerd && input.runnerExecutionTarget?.kind === "remote"
@@ -6203,6 +6232,7 @@ async function createRunnerdBackendWithinSessionClaim(
     runId: input.execution.binding.runId,
     agentId: input.execution.binding.agentId,
     normalizedSessionId: nativeSessionKey(input.execution),
+    pinnedMcpDigest: "runtimeContext" in input.execution ? input.execution.runtimeContext.mcp.digest : undefined,
     workMode: input.execution.task.workMode,
     enqueueWakeup: input.enqueueWakeup,
   });

server/src/services/native-runtime/paperclip-runner-tool-authority.test.ts

@@ -63,8 +63,9 @@ describe("PaperclipRunnerToolAuthority", () => {
 
   it("advertises only real bindings and reads the bound task", async () => {
     const authority = new PaperclipRunnerToolAuthority(db, { companyId, agentId, issueId, runId });
-    expect(authority.definitions()).toHaveLength(16);
+    expect(authority.definitions()).toHaveLength(18);
     expect(authority.definitions().map((tool) => tool.name)).toEqual(expect.arrayContaining([
+      "connections_search", "connection_request",
       "get_task_context", "get_task_history", "search_tasks", "report_progress",
       "request_human_input",
       "create_task", "set_dependencies",

server/src/services/native-runtime/paperclip-runner-tool-authority.ts

@@ -1,3 +1,7 @@
+import { resolveNativeRuntimeMcpSnapshot } from "./runtime-context.js";
+import { connectionIntentService } from "../connection-intents.js";
+import { RUNTIME_CONNECTION_TOOL_DEFINITIONS } from "../connection-tool-definitions.js";
+import { connectionsSearchInputSchema, connectionRequestInputSchema, CONNECTION_INTENT_AGENT_GUIDANCE } from "@paperclipai/shared";
 import { createHash } from "node:crypto";
 import { runnerApiToolsEnabled } from "./runner-api-rollout.js";
 import { openRunnerApiWorkspaceFile } from "./runner-api-files.js";
@@ -10,10 +14,11 @@ import { workspaceFileResourceService } from "../workspace-file-resources.js";
 import { badRequest, forbidden } from "../../errors.js";
 import { searchRunnerApi } from "./runner-api-catalog.js";
 import { executeRunnerApi, validateRunnerApiCall, RUNNER_API_MAX_BYTES, type RunnerApiFile } from "./runner-api-client.js";
-import { and, desc, eq, isNull } from "drizzle-orm";
+import { and, desc, eq, isNull, notInArray } from "drizzle-orm";
 import type { Db } from "@paperclipai/db";
 import {
   agents,
+  agentWakeupRequests,
   documentRevisions,
   heartbeatRuns,
   issueApprovals,
@@ -46,6 +51,7 @@ type Binding = {
   runId: string;
   agentId: string;
   normalizedSessionId?: string;
+  pinnedMcpDigest?: string;
   /** Server-owned API origin and storage; never obtained from tool input. */
   apiUrl?: string;
   storage?: StorageService;
@@ -61,6 +67,7 @@ type Binding = {
     requestedByActorType: "agent";
     requestedByActorId: string;
     contextSnapshot: Record<string, unknown>;
+    issueStateGuard?: { statuses: string[]; assigneeAgentId: string };
   }) => Promise<unknown>;
 };
 
@@ -90,7 +97,7 @@ export class PaperclipRunnerToolAuthority {
 
   definitions(): Array<Record<string, unknown>> {
     const workMode = this.binding.workMode ?? "standard";
-    return CAPABILITY_SEMANTIC_TOOL_CATALOG
+    return [...RUNTIME_CONNECTION_TOOL_DEFINITIONS, ...CAPABILITY_SEMANTIC_TOOL_CATALOG
       .filter((descriptor) =>
         IMPLEMENTED_OPERATIONS.has(descriptor.operationId)
         && (runnerApiToolsEnabled(this.binding.companyId, this.binding.apiToolsEnabled) || !["search_api", "call_api"].includes(descriptor.operationId))
@@ -100,10 +107,42 @@ export class PaperclipRunnerToolAuthority {
         name: descriptor.operationId,
         description: descriptor.description,
         inputSchema: descriptor.inputSchema,
-      }));
+      }))];
   }
 
   async execute(call: { tool: string; callId: string; arguments: unknown }): Promise<unknown> {
+    if (RUNTIME_CONNECTION_TOOL_DEFINITIONS.some((tool) => tool.name === call.tool)) {
+      await this.#boundContext();
+      const { run } = await captureRunIdentity(this.db, this.binding);
+      if (!run.responsibleUserId) throw forbidden("This task needs a responsible user before requesting a connection");
+      const claims = {
+        sub: this.binding.agentId, company_id: this.binding.companyId,
+        run_id: this.binding.runId, responsible_user_id: run.responsibleUserId,
+      };
+      const connections = connectionIntentService(this.db);
+      if (call.tool === "connections_search") return connections.search(claims, connectionsSearchInputSchema.parse(call.arguments).query);
+      const result = await connections.request(claims, connectionRequestInputSchema.parse(call.arguments).service);
+      if (result.state === "ready" && this.binding.pinnedMcpDigest && this.binding.enqueueWakeup) {
+        const current = await resolveNativeRuntimeMcpSnapshot({ db: this.db, agent: { id: this.binding.agentId, companyId: this.binding.companyId }, runId: this.binding.runId });
+        if (current.digest !== this.binding.pinnedMcpDigest) {
+          const idempotencyKey = `connection-intent:tools:${this.binding.runId}:${current.digest}`;
+          const delivered = () => this.db.select({ id: agentWakeupRequests.id }).from(agentWakeupRequests).where(and(
+            eq(agentWakeupRequests.companyId, this.binding.companyId), eq(agentWakeupRequests.idempotencyKey, idempotencyKey),
+            notInArray(agentWakeupRequests.status, ["skipped", "failed", "cancelled"]),
+          )).limit(1);
+          if (!(await delivered()).length) try { await this.binding.enqueueWakeup(this.binding.agentId, {
+            source: "assignment", triggerDetail: "system", reason: "issue_assigned",
+            payload: { issueId: this.binding.issueId, mutation: "connection_tools_refreshed" },
+            idempotencyKey,
+            issueStateGuard: { statuses: ["in_progress", "in_review"], assigneeAgentId: this.binding.agentId },
+            requestedByActorType: "agent", requestedByActorId: this.binding.agentId,
+            contextSnapshot: { issueId: this.binding.issueId, taskId: this.binding.issueId, forceFreshSession: true, wakeReason: "issue_assigned", source: "connection_tools.refreshed" },
+          }); } catch (error) { if (!(await delivered()).length) throw error; }
+          return { ...result, instruction: "Access is already authorized. A fresh continuation with updated tools is queued. Finish independent work, then yield. Do not request authorization again." };
+        }
+      }
+      return result;
+    }
     if (!IMPLEMENTED_OPERATIONS.has(call.tool)) throw new Error("paperclip_runner_tool_not_advertised");
     if (!runnerApiToolsEnabled(this.binding.companyId, this.binding.apiToolsEnabled) && ["search_api", "call_api"].includes(call.tool)) throw new Error("paperclip_runner_tool_not_advertised");
     const context = await this.#boundContext();
@@ -126,6 +165,7 @@ export class PaperclipRunnerToolAuthority {
           status: context.run.status,
           invocationSource: context.run.invocationSource,
         },
+        connectionGuidance: CONNECTION_INTENT_AGENT_GUIDANCE,
         acceptedPlan: await this.#acceptedPlan(context.run.contextSnapshot),
       };
       case "get_task_history": {

server/src/services/native-runtime/status-decision-committer.ts

@@ -1,4 +1,4 @@
-import { and, asc, desc, eq, inArray, sql } from "drizzle-orm";
+import { and, asc, desc, eq, inArray, notInArray, sql } from "drizzle-orm";
 import type { Db } from "@paperclipai/db";
 import type { CreateIssueThreadInteraction } from "@paperclipai/shared";
 import {
@@ -459,6 +459,15 @@ async function materializeDecisionEffect(input: {
   }
   if (effect.kind === "enqueue_continuation") {
     failAt("continuation_materialization", input.failpoint);
+    if (effect.idempotencyKey.startsWith(`connection-intent:tools:${input.runId}:`)) {
+      const [refresh] = await input.tx.select({ id: agentWakeupRequests.id }).from(agentWakeupRequests).where(and(
+        eq(agentWakeupRequests.companyId, input.companyId), eq(agentWakeupRequests.agentId, effect.agentId),
+        eq(agentWakeupRequests.idempotencyKey, effect.idempotencyKey),
+        notInArray(agentWakeupRequests.status, ["skipped", "failed", "cancelled"]),
+      )).limit(1);
+      if (refresh) return { effectKind: effect.kind, targetType: "agent_wakeup_request", targetId: refresh.id,
+        payload: { continuationKind: effect.continuationKind, summary: effect.summary } };
+    }
     const wakeId = await enqueueWake({
       tx: input.tx,
       companyId: input.companyId,

server/src/services/tool-access.ts

@@ -8789,13 +8789,14 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}
 
     let existingApplication: typeof toolApplications.$inferSelect | null = null;
     let requestedResumeConnection: typeof toolConnections.$inferSelect | null = null;
-    if (input.resumeConnectionId) {
+    const requestedConnectionId = input.resumeConnectionId ?? input.reconnectConnectionId;
+    if (requestedConnectionId) {
       const [connection] = await db.select().from(toolConnections).where(and(
-        eq(toolConnections.id, input.resumeConnectionId),
+        eq(toolConnections.id, requestedConnectionId),
         eq(toolConnections.companyId, companyId),
       ));
       if (!connection) throw notFound("Incomplete app connection not found");
-      if (connection.status !== "draft") {
+      if (input.resumeConnectionId && connection.status !== "draft") {
         throw conflict("Only an incomplete app connection can resume setup", {
           code: "connection_setup_not_incomplete",
         });
@@ -8808,6 +8809,10 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}
         eq(toolApplications.companyId, companyId),
       ));
       if (!application) throw notFound("App not found");
+      const source = asRecord(connection.config).sourceTemplateKey ?? asRecord(connection.transportConfig).sourceTemplateKey ?? asRecord(application.metadata).sourceTemplateKey ?? asRecord(application.metadata).source;
+      if (input.reconnectConnectionId && ((galleryEntry && source !== galleryEntry.slug) || (!galleryEntry && typeof source === "string" && getConnectableAppDefinition(source)))) {
+        throw badRequest("Reconnect must preserve the configured provider");
+      }
       requestedResumeConnection = connection;
       existingApplication = application;
     } else if (input.applicationId) {
@@ -9923,6 +9928,7 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}
           metadata: { source: "app_gallery_finish" },
         }));
     const transactionResult = await db.transaction(async (tx) => {
+      await tx.select({ id: toolConnections.id }).from(toolConnections).where(and(eq(toolConnections.id, connectionId), eq(toolConnections.companyId, companyId))).for("update");
       const [existingProfile] = await tx
         .select()
         .from(toolProfiles)
@@ -9930,6 +9936,12 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}
         .limit(1);
       let profileId: string;
       if (existingProfile) {
+        if (input.preserveExistingAccess) {
+          const priorBindings = await tx.select().from(toolProfileBindings).where(eq(toolProfileBindings.profileId, existingProfile.id));
+          for (const prior of priorBindings) if (!bindingInputs.some((binding) => binding.targetType === prior.targetType && binding.targetId === prior.targetId)) bindingInputs.push({ targetType: prior.targetType, targetId: prior.targetId, priority: prior.priority, metadata: prior.metadata });
+          const priorEntries = await tx.select().from(toolProfileEntries).where(eq(toolProfileEntries.profileId, existingProfile.id));
+          for (const prior of priorEntries) if (!entries.some((entry) => entry.catalogEntryId && entry.catalogEntryId === prior.catalogEntryId)) entries.push({ selectorType: prior.selectorType, effect: prior.effect, applicationId: prior.applicationId, connectionId: prior.connectionId, catalogEntryId: prior.catalogEntryId, toolName: prior.toolName, riskLevel: prior.riskLevel, conditions: prior.conditions });
+        }
         await tx
           .delete(toolProfileBindings)
           .where(and(eq(toolProfileBindings.companyId, companyId), eq(toolProfileBindings.profileId, existingProfile.id)));
@@ -10048,6 +10060,7 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}
         companyId,
         connection,
         askFirstEntries: askFirstRows,
+        disableStale: !input.preserveExistingAccess,
         actor,
       }, tx);
       const [updatedConnection] = await tx
@@ -10801,7 +10814,17 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}
     suggestedDefaults: ConnectToolAppResult["suggestedDefaults"];
     activateQuarantined?: boolean;
     actor?: ActorInfo;
+    interactionId?: string | null;
   }) {
+    const linkedInteraction = input.interactionId
+      ? await db.select({ kind: issueThreadInteractions.kind }).from(issueThreadInteractions).where(and(
+          eq(issueThreadInteractions.id, input.interactionId),
+          eq(issueThreadInteractions.companyId, input.connection.companyId),
+        )).limit(1).then((rows) => rows[0] ?? null)
+      : null;
+    // A task callback only prepares the catalog. The intent completion transaction
+    // validates current ownership and adds the requesting agent's access.
+    const deferTaskAccess = linkedInteraction?.kind === "connection_intent";
     const installs = await db.select().from(toolConnectionInstalls).where(and(
       eq(toolConnectionInstalls.companyId, input.connection.companyId),
       eq(toolConnectionInstalls.connectionId, input.connection.id),
@@ -10820,7 +10843,9 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}
       : suggestedAgentIds.length > 0
         ? { agentIds: suggestedAgentIds }
         : "all_agents";
-    const access: FinishToolApp["access"] = installs.length === 0
+    const access: FinishToolApp["access"] = deferTaskAccess
+      ? { agentIds: [] }
+      : installs.length === 0
       ? normalizedSuggestedAccess
       : companyInstall
         ? "all_agents"
@@ -10844,8 +10869,9 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}
         ? enabledCatalog.filter((entry) => entry.status === "quarantined").map((entry) => entry.id)
         : undefined,
       access,
+      preserveExistingAccess: deferTaskAccess,
     }, input.actor);
-    if (installs.length === 0) {
+    if (!deferTaskAccess && installs.length === 0) {
       const installTargets = access === "all_agents"
         ? [{ targetType: "company" as const, targetId: input.connection.companyId }]
         : [...new Set(access.agentIds)].map((agentId) => ({ targetType: "agent" as const, targetId: agentId }));
@@ -11137,6 +11163,7 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}
       : recommended;
     const finished = shouldFinalizeManagedDefaults
       ? await finishOAuthCatalogWithRecommendedDefaults({
+          interactionId: stateRow.interactionId,
           connection,
           catalog: refresh.catalog,
           suggestedDefaults,
@@ -11286,6 +11313,7 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}
     const method = connectionMethodForConnection(galleryEntry, connection);
     const refresh = await refreshCatalog(connection.id, input.actor, {
       enableAllByDefault: true,
+      skipDefaultProfileSync: true,
       credentialHeaders: {
         ...projectedConnectionHeaders(connection),
         [credential.headerName]: `${credential.headerPrefix ?? ""}${token.token}`,
@@ -11293,6 +11321,7 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}
     });
     const suggestedDefaults = recommendedDefaultsForApp(galleryEntry, method.key);
     const finished = await finishOAuthCatalogWithRecommendedDefaults({
+      interactionId: stateRow.interactionId,
       connection,
       catalog: refresh.catalog,
       suggestedDefaults,
@@ -11544,6 +11573,7 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}
       // Activate and discover with the just-issued token before returning.
       const refresh = await refreshCatalog(connection.id, input.actor, {
         enableAllByDefault: true,
+      skipDefaultProfileSync: true,
         credentialHeaders: { Authorization: `Bearer ${token.accessToken}` },
       });
       const [application] = await db.select().from(toolApplications).where(eq(toolApplications.id, connection.applicationId));
@@ -11552,6 +11582,7 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}
         ? recommendedDefaultsForApp(galleryEntry, connectionMethodForConnection(galleryEntry, connection).key)
         : { access: "all_agents" as const, askFirstRiskLevels: [] };
       const finished = await finishOAuthCatalogWithRecommendedDefaults({
+        interactionId: stateRow.interactionId,
         connection,
         catalog: refresh.catalog,
         suggestedDefaults,
@@ -11697,7 +11728,7 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}
     });
 
     await checkConnectionHealth(connection.id, input.actor);
-    const refresh = await refreshCatalog(connection.id, input.actor, { enableAllByDefault: true });
+    const refresh = await refreshCatalog(connection.id, input.actor, { enableAllByDefault: true, skipDefaultProfileSync: true });
     const [application] = await db.select().from(toolApplications).where(eq(toolApplications.id, connection.applicationId));
     const suggestedDefaults = galleryEntry ? recommendedDefaultsForApp(
       galleryEntry,
@@ -11707,6 +11738,7 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}
       askFirstRiskLevels: [],
     };
     const finished = await finishOAuthCatalogWithRecommendedDefaults({
+      interactionId: stateRow.interactionId,
       connection,
       catalog: refresh.catalog,
       suggestedDefaults,
@@ -11735,7 +11767,9 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}
     connectionId: string,
     input: FinalizeOAuthAccess,
     actor?: ActorInfo,
+    requestingAgentId?: string,
   ): Promise<FinishToolAppResult> {
+    if (requestingAgentId) await assertAgentsInCompany(companyId, [requestingAgentId]);
     let connection = await getConnectionRow(connectionId, companyId);
     if (connection.authKind !== "oauth") throw badRequest("This connection does not use browser sign-in");
     if (connection.status === "archived") throw conflict("Archived app connections cannot be finished");
@@ -11953,13 +11987,14 @@ export function toolAccessService(db: Db, options: ToolAccessServiceOptions = {}
       askFirstCatalogEntryIds: catalog
         .filter((entry) => askFirstRiskLevels.has(entry.riskLevel))
         .map((entry) => entry.id),
-      access: "all_agents",
+      access: requestingAgentId ? { agentIds: [requestingAgentId] } : "all_agents",
+      preserveExistingAccess: Boolean(requestingAgentId),
     }, actor);
     await db.insert(toolConnectionInstalls).values({
       companyId,
       connectionId: connection.id,
-      targetType: "company",
-      targetId: companyId,
+      targetType: requestingAgentId ? "agent" : "company",
+      targetId: requestingAgentId ?? companyId,
       createdByUserId: actorUserId,
     }).onConflictDoNothing();
     return finished;

tests/e2e/fixtures/in-feed-bin/codex

@@ -0,0 +1,2 @@
+#!/bin/sh
+exec node "$(dirname "$0")/../in-feed-codex.mjs" "$@"

tests/e2e/fixtures/in-feed-codex.mjs

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+// Deterministic provider only. The production Rust runner, tool authority, and
+// authenticated MCP gateway still execute every tool and enforce access.
+import { randomUUID } from 'node:crypto';
+import { readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { createInterface } from 'node:readline';
+if (process.argv.includes('--version')) { console.log('codex-cli 0.115.0 (in-feed fixture)'); process.exit(0); }
+let threadId = `fixture-${randomUUID()}`;
+let turnId, toolSequence = 0, declined = false;
+let completionContract = { revision: "1", criterionIds: ["objective"] };
+const pending = new Map();
+const send = (value) => process.stdout.write(`${JSON.stringify(value)}\n`);
+const call = (tool, args) => new Promise((resolve, reject) => {
+  const id = `connection-tool-${++toolSequence}`;
+  pending.set(id, { resolve, reject });
+  send({ id, method: 'item/tool/call', params: { threadId, turnId, callId: id, tool, arguments: args } });
+});
+function unwrap(result) {
+  const texts = result?.contentItems ?? result?.content ?? [];
+  for (const item of texts) {
+    try { const parsed = JSON.parse(item.text); return parsed.value ?? parsed; } catch {}
+  }
+  return result;
+}
+async function mcp(method, params = {}) {
+  // Native execution creates a dedicated provider home and issues a short-lived
+  // gateway token for this fixture run. Never load the user's normal Codex home.
+  if (!process.env.CODEX_HOME || !process.env.HOME
+    || resolve(process.env.CODEX_HOME) !== resolve(process.env.HOME)) {
+    throw new Error('The fixture requires an isolated native provider home');
+  }
+  const config = readFileSync(join(process.env.CODEX_HOME, 'config.toml'), 'utf8');
+  const url = JSON.parse(config.match(/^url = (.+)$/m)?.[1] ?? 'null');
+  const authorization = JSON.parse(config.match(/Authorization = (".*?")/m)?.[1] ?? 'null');
+  if (!url || !authorization) throw new Error('Native continuation did not install the MCP gateway');
+  const endpoint = new URL(url);
+  if (endpoint.protocol !== 'http:' || !['127.0.0.1', 'localhost', '[::1]'].includes(endpoint.hostname)
+    || endpoint.username || endpoint.password || endpoint.hash) {
+    throw new Error('The fixture only accepts a local native gateway');
+  }
+  const response = await fetch(endpoint, { redirect: 'error', method: 'POST', headers: { Authorization: authorization, 'Content-Type': 'application/json', Accept: 'application/json, text/event-stream' }, body: JSON.stringify({ jsonrpc: '2.0', id: ++toolSequence, method, params }) });
+  if (!response.ok) throw new Error(`Gateway HTTP ${response.status}`);
+  const text = await response.text();
+  const envelope = JSON.parse(text.startsWith('event:') || text.startsWith('data:') ? text.split('\n').find((line) => line.startsWith('data:')).slice(5) : text);
+  if (envelope.error) throw new Error(envelope.error.message);
+  return envelope.result;
+}
+async function finish(text, evidenceRef) {
+  return call('paperclip_finish', { schema: 'paperclip.run_result.v1', reportedWorkDisposition: 'done', summary: text,
+    completionClaim: { contractRevision: completionContract.revision, objectiveSatisfied: true, criteria: completionContract.criterionIds.map((criterionId) => ({ criterionId, status: 'satisfied', evidenceRefs: [evidenceRef] })), remainingWork: [] },
+    evidence: [{ ref: evidenceRef }], verification: [{ commandOrCheck: 'Fixture outcome', status: 'passed' }], attentionRequests: [], artifacts: [] });
+}
+async function execute() {
+  if (declined) {
+    const text = 'Connection declined. I will use the information already in this task and pursue alternatives.';
+    await call('report_progress', { idempotencyKey: `declined-${turnId}`, body: text });
+    await finish(text, 'task:declined-alternative');
+    send({ method: 'item/completed', params: { threadId, turnId, item: { id: `answer-${turnId}`, type: 'agentMessage', text } } });
+    send({ method: 'turn/completed', params: { threadId, turn: { id: turnId, status: 'completed' } } });
+    return;
+  }
+  const discovery = unwrap(await call('connections_search', { query: 'heliotrope' }));
+  const service = discovery.results?.find((item) => item.source === 'configured');
+  if (!service) throw new Error('Authorized Research Archive fixture was not discoverable');
+  const request = unwrap(await call('connection_request', { service: service.service }));
+  const refreshingTools = request.state === 'ready' && request.instruction?.includes('fresh continuation with updated tools is queued');
+  let text;
+  if (request.state === 'needs_user_action') {
+    text = 'I need access to the research archive. I can organize the launch checklist while you connect it.';
+  } else if (refreshingTools) {
+    // Follow the authority's yield instruction when authorization arrives after
+    // this provider session pinned its tools. The next session must do the read.
+    text = 'Access is ready. I will continue the archive read with the updated tools.';
+  } else {
+    await mcp('initialize', { protocolVersion: '2024-11-05', capabilities: {}, clientInfo: { name: 'in-feed-fixture', version: '1' } });
+    const list = await mcp('tools/list');
+    const tool = list.tools.find((item) => /heliotrope/.test(item.description ?? '') || /archive_read/.test(item.name));
+    if (!tool) throw new Error('Updated native tool snapshot does not contain archive_read');
+    const result = await mcp('tools/call', { name: tool.name, arguments: {} });
+    if (result.isError) throw new Error(JSON.stringify(result));
+    text = result.content.filter((item) => item.type === 'text').map((item) => item.text).join('\n');
+    if (!text.includes('HELIOTROPE-42')) throw new Error('Provider fixture value missing');
+  }
+  await call('report_progress', { idempotencyKey: `fixture-answer-${turnId}`, body: text });
+  if (request.state === 'ready' && !refreshingTools) await finish(text, 'mcp:archive_read');
+  send({ method: 'item/completed', params: { threadId, turnId, item: { id: `answer-${turnId}`, type: 'agentMessage', text } } });
+  send({ method: 'turn/completed', params: { threadId, turn: { id: turnId, status: 'completed' } } });
+}
+createInterface({ input: process.stdin }).on('line', (line) => {
+  const message = JSON.parse(line);
+  if (!message.method && pending.has(message.id)) {
+    const promise = pending.get(message.id); pending.delete(message.id);
+    message.error ? promise.reject(new Error(message.error.message)) : promise.resolve(message.result); return;
+  }
+  const { id, method } = message;
+  if (method === 'initialize') send({ id, result: { user: { sessionId: threadId } } });
+  else if (method === 'thread/start' || method === 'thread/resume') {
+    if (method === 'thread/resume' && message.params?.threadId) threadId = message.params.threadId;
+    if (message.params?.completionContract) completionContract = message.params.completionContract;
+    send({ id, result: { model: 'in-feed-fixture', modelProvider: 'fixture', thread: { id: threadId, sessionId: threadId } } });
+  }
+  else if (method === 'thread/read') send({ id, result: { thread: { id: threadId, turns: [] } } });
+  else if (method === 'turn/start') {
+    declined = /connection_intent/.test(JSON.stringify(message.params)) && /rejected/.test(JSON.stringify(message.params));
+    for (const part of message.params?.input ?? []) {
+      try {
+        const envelope = JSON.parse(part.text);
+        const contract = envelope.task?.completionContract ?? envelope.completionContract;
+        if (contract?.revision && contract.criteria) completionContract = { revision: contract.revision, criterionIds: contract.criteria.map((criterion) => criterion.id) };
+      } catch { /* Non-envelope text is ordinary task context. */ }
+    }
+    turnId = randomUUID();
+    send({ id, result: { turn: { id: turnId, status: 'inProgress' } } });
+    send({ method: 'turn/started', params: { threadId, turn: { id: turnId, status: 'inProgress' } } });
+    // Deliver model output on a later tick, after the runner accepts turn/start.
+    setTimeout(() => void execute().catch((error) => {
+      process.stderr.write(`In-feed fixture: ${error.message}\n`);
+      send({ method: 'turn/completed', params: { threadId, turn: { id: turnId, status: 'failed', error: { message: error.message } } } });
+    }), 50);
+  } else if (id != null) send({ id, result: {} });
+});

tests/e2e/in-feed-native/connections.spec.ts

@@ -0,0 +1,175 @@
+import { test, expect } from '@playwright/test';
+import { execFileSync, spawn, type ChildProcess } from 'node:child_process';
+import { createServer } from 'node:http';
+import { resolve } from 'node:path';
+import { writeFile } from 'node:fs/promises';
+import { listenOnFetchAllowedPort } from '../fetch-allowed-port';
+
+// Each attempt starts the source CLI's test-drive without --data-dir. The model
+// and MCP provider are deterministic fixtures; authorization/cards/wakes are real.
+for (const journey of ['connect', 'decline', 'restart'] as const) test(`fresh native runner connection journey: ${journey}`, async ({ page }, info) => {
+  const root = resolve(import.meta.dirname, '../../..');
+  let processHandle: ChildProcess | undefined;
+  let logs = '';
+  let diagnosticState = async () => ({});
+  const calls: string[] = [];
+  const fixture = createServer(async (req, res) => {
+    const chunks: Buffer[] = []; for await (const part of req) chunks.push(Buffer.from(part));
+    const message = JSON.parse(Buffer.concat(chunks).toString() || '{}');
+    calls.push(message.method);
+    if (message.id === undefined) { res.writeHead(202); res.end(); return; }
+    const result = message.method === 'initialize' ? { protocolVersion: '2024-11-05', capabilities: { tools: {} }, serverInfo: { name: 'heliotrope', version: '1' } }
+      : message.method === 'tools/list' ? { tools: [{ name: 'archive_read', description: 'Read heliotrope launch decisions', inputSchema: { type: 'object', properties: {}, additionalProperties: false } }] }
+      : message.method === 'tools/call' ? { content: [{ type: 'text', text: 'HELIOTROPE-42: Launch in two stages; support handoff belongs to Mira. Source: https://example.invalid/launch/heliotrope-42' }] } : {};
+    res.writeHead(200, { 'content-type': 'application/json' }); res.end(JSON.stringify({ jsonrpc: '2.0', id: message.id, result }));
+  });
+  try {
+    const port = await listenOnFetchAllowedPort(fixture);
+    const env = { ...process.env, IN_FEED_FIXTURE_KEY: 'not-a-real-model-key', NODE_ENV: 'test', PAPERCLIP_TEST_CONNECTION_DELIVERY_HOLD: journey === 'restart' ? '1' : '0', PATH: `${root}/tests/e2e/fixtures/in-feed-bin:${process.env.PATH}` };
+    delete env.DATABASE_URL; delete env.DATABASE_MIGRATION_URL;
+    processHandle = spawn(process.execPath, ['cli/node_modules/tsx/dist/cli.mjs', 'cli/src/index.ts', 'test-drive', '--harness', 'codex', '--api-key-env', 'IN_FEED_FIXTURE_KEY', '--company-name', 'In-feed native fixture', '--no-browser'], { cwd: root, env, detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
+    processHandle.stdout!.on('data', (chunk) => { logs += chunk.toString(); });
+    processHandle.stderr!.on('data', (chunk) => { logs += chunk.toString(); });
+    await expect.poll(() => logs.match(/Paperclip is ready at (http:\/\/127\.0\.0\.1:\d+)/)?.[1], { timeout: 100_000 }).toBeTruthy();
+    let base = logs.match(/Paperclip is ready at (http:\/\/127\.0\.0\.1:\d+)/)![1]!;
+    const api = async (path: string, method = 'GET', data?: unknown) => {
+      const response = await page.request.fetch(`${base}/api${path}`, { method, data });
+      expect(response.ok(), await response.text()).toBeTruthy(); return response.json();
+    };
+    const isSettledRun = (run: { status: string; errorCode?: string }) => run.status === 'succeeded'
+      || (run.status === 'cancelled' && run.errorCode === 'issue_not_in_progress');
+    const health = await api('/health');
+    expect(health).toMatchObject({ status: 'ok', deploymentMode: 'local_trusted', bootstrapStatus: 'ready', serverInfo: { git: { branchName: execFileSync('git', ['branch', '--show-current'], { cwd: root, encoding: 'utf8' }).trim() } } });
+    const [company] = await api('/companies');
+    const [agent] = await api(`/companies/${company.id}/agents`);
+    expect(agent.adapterType).toBe('codex_local');
+    expect(await api(`/companies/${company.id}/issues`)).toEqual([]);
+    expect(await api(`/companies/${company.id}/heartbeat-runs`)).toEqual([]);
+    expect((await api(`/companies/${company.id}/tools/connections`)).connections).toEqual([]);
+    diagnosticState = async () => ({ base, companyId: company.id, agentId: agent.id,
+      tasks: (await api(`/companies/${company.id}/issues`)).map((task: Record<string, unknown>) => ({ id: task.id, status: task.status, assigneeAgentId: task.assigneeAgentId })),
+      runs: (await api(`/companies/${company.id}/heartbeat-runs`)).map((run: Record<string, unknown>) => ({ id: run.id, status: run.status, runtimeMode: run.runtimeMode, error: run.error, errorCode: run.errorCode })),
+    });
+    const dataDir = logs.match(/Data directory: ([^\n\r]+)/)![1]!.replace(/\u001b\[[0-9;]*m/g, '').trim();
+    const prefix = `/${company.issuePrefix}`;
+    await page.goto(base + prefix + '/dashboard');
+    await expect(page.getByText('No runs yet').first()).toBeVisible();
+    await page.goto(base + prefix + '/company/settings/instance/experimental');
+    await page.getByRole('switch', { name: 'Toggle Paperclip Runner experimental setting' }).click();
+    await expect.poll(async () => (await api('/instance/settings/experimental')).enableNativeRunner).toBe(true);
+    await page.goto(base + prefix + `/agents/${agent.id}/configuration`);
+    await page.getByRole('button', { name: 'Codex', exact: true }).click();
+    await page.getByRole('button', { name: /Paperclip Runner/ }).click();
+    await page.getByRole('button', { name: 'Save', exact: true }).first().click();
+    await expect.poll(async () => (await api(`/agents/${agent.id}`)).adapterType).toBe('paperclip_runner');
+    const nativeAgent = await api(`/agents/${agent.id}`);
+    expect(nativeAgent.adapterConfig.env).toEqual(agent.adapterConfig.env);
+    const holder = await api(`/companies/${company.id}/agents`, 'POST', { name: 'Archive holder', role: 'qa', adapterType: 'process', adapterConfig: { command: process.execPath, args: ['-e', 'process.exit(0)'] } });
+    await page.goto(base + prefix + '/apps');
+    const custom = page.getByRole('list', { name: 'Connector list' }).getByRole('listitem').filter({ hasText: 'Connect your own tool' });
+    await custom.getByRole('button', { name: 'Connect', exact: true }).click();
+    await custom.getByRole('button', { name: 'Connect your own MCP server' }).click();
+    await page.getByPlaceholder('https://example.com/actions').fill(`http://127.0.0.1:${port}/`);
+    await page.getByRole('button', { name: 'Continue', exact: true }).click();
+    await page.getByRole('radio', { name: 'Just agents I pick' }).click();
+    await page.getByRole('button', { name: /Select agents/ }).click();
+    await page.getByRole('checkbox', { name: /Archive holder/ }).check();
+    await page.keyboard.press('Escape');
+    await page.getByRole('button', { name: 'Save and continue' }).click();
+    await page.getByRole('button', { name: /Check link/i }).click();
+    await expect(page.getByRole('heading', { name: /is ready/i })).toBeVisible({ timeout: 30_000 });
+    const [connection] = (await api(`/companies/${company.id}/tools/connections`)).connections;
+    const installs = (await api(`/tool-connections/${connection.id}/installs`)).installs;
+    expect(installs).toEqual([expect.objectContaining({ targetId: holder.id })]);
+    await page.getByRole('link', { name: 'Tasks', exact: true }).click();
+    await page.getByRole('button', { name: 'New Task', exact: true }).last().click();
+    await page.getByPlaceholder('Task title').fill('Find the heliotrope launch notes and summarize the decisions with a source link');
+    await page.getByRole('button', { name: 'Assignee', exact: true }).click();
+    await page.getByRole('button', { name: 'CEO', exact: true }).click();
+    await page.getByRole('button', { name: 'Create Task', exact: true }).click();
+    await page.getByRole('complementary').getByRole('link', { name: /Find the heliotrope launch notes/ }).click();
+    await expect(page).toHaveURL(/issues\/(?:[a-f0-9-]+|INF-\d+)/);
+    await expect(page.getByText(/CEO needs/)).toBeVisible({ timeout: 60_000 });
+    await expect(page.getByTestId('connection-intent-focus-target')).toHaveCount(1);
+    await expect.poll(async () => (await api(`/companies/${company.id}/heartbeat-runs`)).every((run: { status: string }) => run.status === 'succeeded'), { timeout: 60_000 }).toBe(true);
+    await page.screenshot({ path: info.outputPath('pending-card.png'), fullPage: true });
+    const composer = page.getByRole('textbox').last();
+    await composer.fill('While I connect, organize the checklist.');
+    await expect(composer).toBeEditable();
+    if (journey === 'connect') await page.getByRole('button', { name: 'Send', exact: true }).click();
+    else await composer.fill('');
+    await expect(page.getByTestId('connection-intent-focus-target')).toHaveCount(1);
+    if (journey === 'decline') {
+      await page.getByRole('button', { name: 'Not now', exact: true }).click();
+      await expect(page.getByText('Connection declined', { exact: true })).toBeVisible();
+      await expect(page.getByText(/I will use the information already in this task/).first()).toBeVisible({ timeout: 60_000 });
+      await expect(page.getByTestId('connection-intent-focus-target')).toHaveCount(1);
+      expect(calls.filter((method) => method === 'tools/call')).toHaveLength(0);
+      await expect.poll(async () => (await api(`/companies/${company.id}/heartbeat-runs`)).every((run: { status: string }) => run.status === 'succeeded'), { timeout: 60_000 }).toBe(true);
+      const runs = await Promise.all((await api(`/companies/${company.id}/heartbeat-runs`)).map((run: { id: string }) => api(`/heartbeat-runs/${run.id}`)));
+      expect(runs.every((run: { runtimeMode: string }) => run.runtimeMode === 'native')).toBe(true);
+      await writeFile(info.outputPath('instance-and-runs.json'), JSON.stringify({ base, dataDir, health, journey, companyId: company.id, agentId: agent.id,
+        connectionId: connection.id, dependency: 'fixture', provider: 'codex', fixtureModel: 'in-feed-fixture',
+        runs: runs.map((run: Record<string, unknown>) => ({ id: run.id, status: run.status, runtimeMode: run.runtimeMode })) }, null, 2));
+      await page.screenshot({ path: info.outputPath('declined-continuation.png'), fullPage: true });
+      return;
+    }
+    await page.getByRole('button', { name: /Connect \/ Use existing/ }).click();
+    await expect(page.getByRole('dialog')).toBeVisible();
+    await page.screenshot({ path: info.outputPath('setup-dialog.png'), fullPage: true });
+    await page.getByRole('button', { name: new RegExp(connection.name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')) }).click();
+    await expect(page.getByText(`${connection.name} connected`, { exact: true })).toBeVisible({ timeout: 30_000 });
+    await page.getByTestId('connection-intent-focus-target').scrollIntoViewIfNeeded();
+    await page.screenshot({ path: info.outputPath('connected-card.png'), fullPage: true });
+    if (journey === 'restart') {
+      expect(calls.filter((method) => method === 'tools/call')).toHaveLength(0);
+      await writeFile(info.outputPath('before-restart.log'), logs);
+      const exit = new Promise<void>((done) => processHandle!.once('exit', () => done()));
+      process.kill(-processHandle!.pid!, 'SIGTERM'); await exit;
+      logs = '';
+      processHandle = spawn(process.execPath, ['cli/node_modules/tsx/dist/cli.mjs', 'cli/src/index.ts', 'test-drive', '--harness', 'codex', '--api-key-env', 'IN_FEED_FIXTURE_KEY', '--data-dir', dataDir, '--no-browser'], { cwd: root, env: { ...env, PAPERCLIP_TEST_CONNECTION_DELIVERY_HOLD: '0' }, detached: true, stdio: ['ignore', 'pipe', 'pipe'] });
+      processHandle.stdout!.on('data', (chunk) => { logs += chunk.toString(); });
+      processHandle.stderr!.on('data', (chunk) => { logs += chunk.toString(); });
+      await expect.poll(() => logs.match(/Paperclip is ready at (http:\/\/127\.0\.0\.1:\d+)/)?.[1], { timeout: 100_000 }).toBeTruthy();
+      base = logs.match(/Paperclip is ready at (http:\/\/127\.0\.0\.1:\d+)/)![1]!;
+      expect((await api('/companies'))[0].id).toBe(company.id);
+      const taskId = (await api(`/companies/${company.id}/issues`))[0].id;
+      await page.goto(base + prefix + '/issues/' + taskId);
+    }
+    await expect(page.getByText(/HELIOTROPE-42: Launch in two stages/).first()).toBeVisible({ timeout: 60_000 });
+    expect(calls.filter((method) => method === 'tools/call')).toHaveLength(1);
+    await expect.poll(async () => (await api(`/companies/${company.id}/heartbeat-runs`)).every(isSettledRun), { timeout: 60_000 }).toBe(true);
+    await expect(page.getByText(/HELIOTROPE-42: Launch in two stages/).first()).toBeVisible();
+    await expect(async () => { await page.getByText(/HELIOTROPE-42: Launch in two stages/).first().scrollIntoViewIfNeeded(); }).toPass({ timeout: 10_000 });
+    const runs = await Promise.all((await api(`/companies/${company.id}/heartbeat-runs`)).map((run: { id: string }) => api(`/heartbeat-runs/${run.id}`)));
+    expect(runs.filter((run: { status: string }) => run.status === 'succeeded').length).toBeGreaterThanOrEqual(2);
+    if (runs.some((run: { status: string }) => run.status === 'cancelled')) {
+      // Independent work may consume the new access before the queued outcome
+      // runs. Closing the task must cancel that redundant wake, not reopen it.
+      expect((await api(`/companies/${company.id}/issues`))[0].status).toBe('done');
+    }
+    expect(runs.filter((run: { status: string }) => run.status === 'succeeded').every((run: { runtimeMode: string }) => run.runtimeMode === 'native')).toBe(true);
+    await expect(page.getByText('The runner returned no user-facing response.', { exact: true })).not.toBeVisible();
+    await page.screenshot({ path: info.outputPath('connected-answer.png'), fullPage: true });
+    await page.reload();
+    await expect(page.getByText(/HELIOTROPE-42: Launch in two stages/).first()).toBeVisible();
+    if (journey === 'connect') {
+      await page.getByRole('textbox').last().fill('What is the support handoff decision in the archive?');
+      await page.getByRole('button', { name: 'Send', exact: true }).click();
+      await expect.poll(() => calls.filter((method) => method === 'tools/call').length, { timeout: 60_000 }).toBe(2);
+      await expect(page.getByTestId('connection-intent-focus-target')).toHaveCount(1);
+      await expect.poll(async () => (await api(`/companies/${company.id}/heartbeat-runs`)).every(isSettledRun), { timeout: 60_000 }).toBe(true);
+    }
+    const finalRuns = await Promise.all((await api(`/companies/${company.id}/heartbeat-runs`)).map((run: { id: string }) => api(`/heartbeat-runs/${run.id}`)));
+    expect(finalRuns.filter((run: { status: string }) => run.status === 'succeeded').every((run: { runtimeMode: string }) => run.runtimeMode === 'native')).toBe(true);
+    const evidence = JSON.stringify({ base, dataDir, health, journey, companyId: company.id, agentId: agent.id, connectionId: connection.id, runs: finalRuns.map((r: Record<string, unknown>) => ({ id: r.id, runtimeMode: r.runtimeMode, status: r.status })), dependency: 'fixture', provider: 'codex', fixtureModel: 'in-feed-fixture' }, null, 2);
+    await writeFile(info.outputPath('instance-and-runs.json'), evidence);
+    await info.attach('instance-and-runs', { body: evidence, contentType: 'application/json' });
+  } finally {
+    await writeFile(info.outputPath('diagnostics.json'), JSON.stringify(await diagnosticState().catch(() => ({})), null, 2));
+    await writeFile(info.outputPath('test-drive.log'), logs);
+    if (processHandle?.pid) { try { process.kill(-processHandle.pid, 'SIGTERM'); } catch {} }
+    fixture.closeAllConnections();
+    await new Promise<void>((done) => fixture.close(() => done()));
+  }
+});

tests/e2e/in-feed-native/playwright.config.ts

@@ -0,0 +1,4 @@
+import { defineConfig } from '@playwright/test';
+export default defineConfig({ testDir: '.', testMatch: '*.spec.ts', workers: 1, timeout: 180_000,
+  use: { actionTimeout: 15_000, headless: true, screenshot: 'only-on-failure', trace: 'retain-on-failure' },
+  outputDir: '../../../test-results/in-feed-native', reporter: [['list']] });

tests/e2e/playwright.config.ts

@@ -32,7 +32,7 @@ export default defineConfig({
   testMatch: "**/*.spec.ts",
   // These suites target dedicated multi-user configurations/ports and are
   // intentionally not part of the default local_trusted e2e run.
-  testIgnore: ["multi-user.spec.ts", "multi-user-authenticated.spec.ts"],
+  testIgnore: ["in-feed-native/**", "multi-user.spec.ts", "multi-user-authenticated.spec.ts"],
   timeout: 60_000,
   retries: 0,
   // All specs share one throwaway server, and several toggle instance-level

tests/storybook-visual/in-feed-connections.config.ts

@@ -0,0 +1,5 @@
+import { defineConfig } from '@playwright/test';
+export default defineConfig({ testDir: '.', testMatch: 'in-feed-connections.spec.ts', workers: 4,
+  timeout: 30_000, retries: 0, outputDir: './test-results/in-feed', reporter: [['list']],
+  use: { browserName: 'chromium', baseURL: 'http://127.0.0.1:6126', reducedMotion: 'reduce' },
+  webServer: { command: 'node ../../scripts/serve-storybook-static.mjs --port 6126', url: 'http://127.0.0.1:6126/index.json', reuseExistingServer: false } });

tests/storybook-visual/in-feed-connections.spec.ts

@@ -0,0 +1,44 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { test, expect } from '@playwright/test';
+const index = JSON.parse(readFileSync(resolve(import.meta.dirname, '../../ui/storybook-static/index.json'), 'utf8'));
+const stories = Object.values(index.entries).filter((entry: any) => entry.id.startsWith('connections-in-task-connections--')) as { id: string; name: string }[];
+for (const story of stories) for (const theme of ['light', 'dark']) {
+  test(`${story.name} / ${theme}`, async ({ page }, info) => {
+    const errors: string[] = [];
+    page.on('pageerror', (error) => errors.push(error.message));
+    await page.setViewportSize({ width: /Narrow/.test(story.name) ? 390 : 1200, height: 844 });
+    await page.goto(`/iframe.html?id=${story.id}&viewMode=story&globals=theme:${theme}`);
+    await page.waitForFunction(() => document.body.classList.contains('sb-show-main') || document.body.classList.contains('sb-show-errordisplay'));
+    await expect(page.locator('.sb-errordisplay')).not.toBeVisible();
+    await page.waitForFunction((id) => document.body.dataset.inFeedStoryReady === id, story.id);
+    expect(await page.locator("body").getAttribute("data-in-feed-story-error")).toBeNull();
+    await page.evaluate(() => document.fonts.ready);
+    await page.evaluate(() => Promise.all(Array.from(document.images).map((image) => image.decode().catch(() => {}))));
+    if (story.id.endsWith('reuse-and-return-focus')) {
+      await expect(page.getByText('Notion connected', { exact: true })).toBeVisible();
+      await expect(page.getByTestId('connection-intent-focus-target')).toBeFocused();
+    }
+    if (story.id.endsWith('pending-with-composer')) await expect(page.getByRole('textbox')).toContainText('While I connect');
+    if (story.id.endsWith('resolution-error')) await expect(page.getByRole('note')).toContainText('no permitted tools');
+    if (story.id.endsWith('permission-denied')) await expect(page.getByRole('note')).toContainText('no longer have permission');
+    if (story.id.endsWith('scrollable-connections')) {
+      await page.getByRole('button', { name: 'Connect new', exact: true }).scrollIntoViewIfNeeded();
+      await expect(page.getByRole('button', { name: 'Connect new', exact: true })).toBeVisible();
+    }
+    await expect.poll(() => errors).toEqual([]);
+    await page.screenshot({ path: info.outputPath(`${story.id}-${theme}.png`), fullPage: true, animations: 'disabled' });
+  });
+}
+test('keyboard opens and closes setup, preserves the composer, and validates personal default', async ({ page }) => {
+  await page.goto('/iframe.html?id=connections-in-task-connections--pending-with-composer&viewMode=story');
+  await page.waitForFunction(() => document.body.dataset.inFeedStoryReady === 'connections-in-task-connections--pending-with-composer');
+  const connect = page.getByRole('button', { name: 'Connect', exact: true });
+  await connect.focus(); await page.keyboard.press('Enter');
+  await expect(page.getByRole('dialog')).toBeVisible();
+  await expect(page.getByRole('radio', { name: 'Just me', exact: true })).toBeChecked();
+  await page.keyboard.press('Escape');
+  await expect(page.getByRole('dialog')).not.toBeVisible();
+  await expect(page.getByRole('textbox')).toBeEditable();
+  await expect(page.getByTestId('connection-intent-focus-target')).toBeFocused();
+});

ui/src/components/IssueThreadInteractionCard.test.tsx

@@ -132,10 +132,10 @@ describe("IssueThreadInteractionCard", () => {
     });
 
     expect(host.querySelector('[data-testid="connection-intent-actions"]')).toBeTruthy();
-    expect(host.textContent).toContain("Connect / Use existing");
+    expect(host.textContent).toContain("Connect");
     expect(host.textContent).toContain("Not now");
     const loadButton = Array.from(host.querySelectorAll("button")).find((button) =>
-      button.textContent?.includes("Connect / Use existing"),
+      button.textContent?.trim() === "Connect",
     );
     await act(async () => {
       loadButton?.click();
@@ -159,7 +159,7 @@ describe("IssueThreadInteractionCard", () => {
     });
 
     expect(host.querySelector('[data-testid="connection-intent-waiting"]')).toBeTruthy();
-    expect(host.textContent).not.toContain("Connect / Use existing");
+    expect(Array.from(host.querySelectorAll("button")).map((button) => button.textContent?.trim())).not.toContain("Connect");
     expect(host.textContent).not.toContain("Not now");
   });
 
@@ -1438,7 +1438,7 @@ describe("IssueThreadInteractionCard connection-intent card", () => {
     });
     expect(host.querySelector('[data-testid="connection-intent-actions"]')).not.toBeNull();
     const labels = Array.from(host.querySelectorAll("button")).map((button) => button.textContent?.trim());
-    expect(labels).toContain("Connect / Use existing");
+    expect(labels).toContain("Connect");
     expect(labels).toContain("Not now");
     expect(host.textContent).toContain("Access is added only for this agent");
   });

ui/src/components/TaskChatThread.test.tsx

@@ -1091,6 +1091,16 @@ describe("TaskChatThread runtime transcript selection", () => {
     },
   );
 
+  it("does not show a completed-response notice for a redundant cancelled continuation", () => {
+    render(<TaskChatThread comments={[]} onAdd={async () => {}} linkedRuns={[{
+      runId: "connection-continuation-skipped", status: "cancelled", errorCode: "issue_not_in_progress", startedAt: null,
+      agentId: "agent-1", agentName: "Runner", adapterType: "paperclip_runner",
+      createdAt: "2026-09-07T18:00:00.000Z", finishedAt: "2026-09-07T18:00:01.000Z",
+    }]} />);
+    expect(container.textContent).not.toContain("The runner returned no user-facing response.");
+    expect(container.textContent).not.toContain("Run completed");
+  });
+
   it("does not treat a progress comment as the final response of a failed native run", () => {
     nativeTranscriptState.transcriptByRun.set("native-progress-failed", [
       {

ui/src/components/TaskChatThread.tsx

@@ -1402,6 +1402,13 @@ export function TaskChatThread(props: TaskChatThreadProps) {
         });
       }
       if (entries.length === 0) {
+        // A queued continuation cancelled after the task was completed or parked
+        // never produced a provider turn. Keep its record in the run log without
+        // presenting it as a completed chat response.
+        if (source.status === "cancelled" && meta?.errorCode === "issue_not_in_progress") {
+          settledRunIds.add(source.id);
+          continue;
+        }
         if (sourceIsPaperclipRunner && sourceYielded) {
           settledRunIds.add(source.id);
           continue;
@@ -2081,6 +2088,7 @@ export function TaskChatThread(props: TaskChatThreadProps) {
       .filter(
         (interaction) =>
           interaction.status === "pending" &&
+          interaction.kind !== "connection_intent" &&
           !shouldHideInteractionCard(interaction),
       )
       .sort((left, right) => toMs(right.createdAt) - toMs(left.createdAt));

ui/src/components/task-chat/TaskChatInteractionCard.tsx

@@ -43,7 +43,7 @@ export function TaskChatInteractionCard({
     interaction.result?.expirationReason === "superseded_by_newer_interaction";
   if (shouldHideInteractionCard(interaction) && !isSupersededQuestionReceipt)
     return null;
-  if (presentation === "timeline" && interaction.status === "pending") {
+  if (presentation === "timeline" && interaction.status === "pending" && interaction.kind !== "connection_intent") {
     const isPlanReview =
       interaction.kind === "request_confirmation" &&
       Boolean(interaction.sourceRunId) &&

ui/src/features/connections/ConnectionIntentInteractionBody.test.tsx

@@ -144,7 +144,7 @@ function renderBody(
 
 function button(label: string) {
   return Array.from(document.body.querySelectorAll("button")).find(
-    (candidate) => candidate.textContent?.trim() === label,
+    (candidate) => candidate.textContent?.trim() === label || (label === "Connect / Use existing" && candidate.textContent?.trim() === "Connect"),
   ) as HTMLButtonElement | undefined;
 }
 
@@ -175,7 +175,7 @@ afterEach(async () => {
 
 describe("ConnectionIntentInteractionBody states and audience", () => {
   it.each([
-    [pendingConnectionIntentInteraction, "Connect / Use existing"],
+    [pendingConnectionIntentInteraction, "Connect"],
     [
       {
         ...pendingConnectionIntentInteraction,
@@ -184,7 +184,7 @@ describe("ConnectionIntentInteractionBody states and audience", () => {
           phase: "authorizing",
         },
       },
-      "Authorizing…",
+      "Continue setup",
     ],
     [retryConnectionIntentInteraction, "Try again"],
     [connectedConnectionIntentInteraction, "Notion connected"],

ui/src/features/connections/ConnectionIntentInteractionBody.tsx

@@ -1,4 +1,4 @@
-import { useCallback, useRef, useState } from "react";
+import { useCallback, useEffect, useRef, useState } from "react";
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import {
   CheckCircle2,
@@ -88,10 +88,19 @@ export function ConnectionIntentInteractionBody({
   const setupQuery = useQuery({
     queryKey: ["connection-intent", interaction.id, "setup-options"],
     queryFn: () => connectionIntentsApi.setupOptions(interaction.id),
-    enabled: open && isAddressee && isPending,
-    refetchInterval: open && isPending ? 2_000 : false,
+    enabled: isAddressee && isPending,
+    refetchInterval: isPending && (open || interaction.payload.phase === "authorizing") ? 2_000 : false,
   });
 
+  useEffect(() => {
+    const current = setupQuery.data?.interaction;
+    if (current && current.status !== "pending" && isPending) {
+      void invalidateTask(current);
+      setOpen(false);
+      returnFocusToCard();
+    }
+  }, [setupQuery.data?.interaction, isPending]);
+
   const completeMutation = useMutation({
     mutationFn: (connectionId: string) =>
       connectionIntentsApi.complete(interaction.id, connectionId),
@@ -123,7 +132,10 @@ export function ConnectionIntentInteractionBody({
 
   const finishNewConnection = async (completion: ConnectionSetupCompletion) => {
     if (completion.resolvedByCallback) {
-      await invalidateTask();
+      // A browser message cannot establish authorization. Read the durable result.
+      const verified = await setupQuery.refetch();
+      if (verified.data?.interaction.status !== "accepted") return;
+      await invalidateTask(verified.data.interaction);
       setOpen(false);
       returnFocusToCard();
       return;
@@ -154,7 +166,7 @@ export function ConnectionIntentInteractionBody({
                   : "Connection request expired",
               body:
                 resultOutcome === "superseded"
-                  ? "A newer run requested this connection. Use the latest card instead."
+                  ? "This request was replaced. Use the latest connection card instead."
                   : "This request is no longer active.",
             }
           : null;
@@ -247,20 +259,28 @@ export function ConnectionIntentInteractionBody({
           </p>
         ) : null}
 
-        <div className="mt-4 flex flex-wrap gap-2">
+        <div className="mt-4 flex flex-wrap justify-end gap-2">
+          <Button
+            type="button"
+            variant="ghost"
+            disabled={declineMutation.isPending || authorizing}
+            onClick={() => declineMutation.mutate()}
+          >
+            Not now
+          </Button>
           <Dialog open={open} onOpenChange={setOpen}>
             <DialogTrigger asChild>
-              <Button type="button" disabled={authorizing}>
+              <Button type="button">
                 {authorizing ? (
                   <Loader2 className="h-4 w-4 animate-spin" />
                 ) : (
                   <Plug className="h-4 w-4" />
                 )}
                 {authorizing
-                  ? "Authorizing…"
+                  ? "Continue setup"
                   : needsRetry
                     ? "Try again"
-                    : "Connect / Use existing"}
+                    : setupQuery.data?.existingConnections.length ? "Connect / Use existing" : "Connect"}
               </Button>
             </DialogTrigger>
             <DialogContent
@@ -304,7 +324,8 @@ export function ConnectionIntentInteractionBody({
               ) : setupQuery.data ? (
                 <ConnectionSetupFlow
                   host="dialog"
-                  serviceSlug={interaction.payload.serviceSlug}
+                  serviceSlug={interaction.payload.serviceSlug.startsWith("connection:") ? undefined : interaction.payload.serviceSlug}
+                  configuredConnection={interaction.payload.serviceSlug.startsWith("connection:") ? setupQuery.data.existingConnections[0] : undefined}
                   requestedAgentId={setupQuery.data.requestedAgentId}
                   interactionId={interaction.id}
                   existingConnections={setupQuery.data.existingConnections}
@@ -321,14 +342,6 @@ export function ConnectionIntentInteractionBody({
               ) : null}
             </DialogContent>
           </Dialog>
-          <Button
-            type="button"
-            variant="ghost"
-            disabled={declineMutation.isPending || authorizing}
-            onClick={() => declineMutation.mutate()}
-          >
-            Not now
-          </Button>
         </div>
 
         {completeMutation.isError ||

ui/src/features/connections/ConnectionSetupFlow.tsx

@@ -20,6 +20,7 @@ import type {
   Agent,
   AppDefinition,
   ConnectionGrantKind,
+  ConnectionIntentSetupConnection,
   ConnectionMethodDef,
   ConnectToolAppResult,
   FieldDef,
@@ -315,7 +316,8 @@ const ZAPIER_STEP_LABELS = ["Access", "Add MCP URL"];
  * it. Personal-only methods still stay personal, and reconnects preserve their
  * original identity through the explicit reconnect hint.
  */
-function defaultGrantKindFor(method: ConnectionMethodDef | null): ConnectionGrantKind {
+function defaultGrantKindFor(method: ConnectionMethodDef | null, preferPersonal = false): ConnectionGrantKind {
+  if (preferPersonal && method?.auth !== "none" && (!method?.grantKinds || method.grantKinds.includes("user"))) return "user";
   if (method?.grantKinds?.length === 1) return method.grantKinds[0]!;
   if (method?.grantKinds && !method.grantKinds.includes("organization")) return method.grantKinds[0]!;
   return "organization";
@@ -476,7 +478,8 @@ export interface ConnectionSetupFlowProps {
   requestedAgentId?: string;
   interactionId?: string;
   forceNewConnection?: boolean;
-  existingConnections?: ToolConnection[];
+  existingConnections?: ConnectionIntentSetupConnection[];
+  configuredConnection?: ConnectionIntentSetupConnection;
   onUseExisting?: (connectionId: string) => Promise<void>;
   onComplete?: (result: ConnectionSetupCompletion) => void;
   onOAuthDeclined?: () => void;
@@ -499,6 +502,7 @@ export function ConnectionSetupFlow({
   interactionId,
   forceNewConnection = false,
   existingConnections = [],
+  configuredConnection,
   onUseExisting,
   onComplete,
   onOAuthDeclined,
@@ -528,7 +532,7 @@ export function ConnectionSetupFlow({
   const oauthCallbackCode = searchParams.get("code");
   const githubInstallationUrl = githubRecoveryUrl(searchParams.get("installation_url"));
   const githubManagementUrl = githubRecoveryUrl(searchParams.get("management_url"));
-  const reconnectConnectionId = searchParams.get("reconnect")?.trim() || null;
+  const reconnectConnectionId = configuredConnection?.id ?? (searchParams.get("reconnect")?.trim() || null);
   const reconnectGrantKindHint: ConnectionGrantKind | null = searchParams.get("identity") === "user"
     ? "user"
     : searchParams.get("identity") === "organization"
@@ -546,7 +550,7 @@ export function ConnectionSetupFlow({
   const routeAppKey = resolveAppsConnectRouteKey({ serviceSlug, appKey, sourceSlug });
   const zapierSource = (serviceSlug ?? sourceSlug ?? appKey) === "zapier";
   const requestedAppKey = zapierSource ? undefined : routeAppKey;
-  const byo = host === "page" && (byoOnly || searchParams.get("byo") === "1");
+  const byo = Boolean(configuredConnection) || (host === "page" && (byoOnly || searchParams.get("byo") === "1"));
   const [restoredEnrollmentAccess] = useState<EnrollmentAccessState | null>(() =>
     host === "page"
       && searchParams.get("cloud_connector") === "enrolled"
@@ -561,8 +565,8 @@ export function ConnectionSetupFlow({
     const rawLink = searchParams.get("link")?.trim() ?? "";
     return {
       link: /^https?:\/\//i.test(rawLink) ? rawLink : "",
-      name: searchParams.get("name")?.trim() ?? "",
-      applicationId: searchParams.get("applicationId")?.trim() || undefined,
+      name: configuredConnection?.name ?? searchParams.get("name")?.trim() ?? "",
+      applicationId: configuredConnection?.applicationId ?? (searchParams.get("applicationId")?.trim() || undefined),
     };
   });
 
@@ -609,7 +613,7 @@ export function ConnectionSetupFlow({
    * backwards through the wizard.
    */
   const [grantKind, setGrantKind] = useState<ConnectionGrantKind>(
-    restoredEnrollmentAccess?.grantKind ?? reconnectGrantKindHint ?? "organization",
+    restoredEnrollmentAccess?.grantKind ?? reconnectGrantKindHint ?? (requestedAgentId ? "user" : "organization"),
   );
   const [installChoice, setInstallChoice] = useState<"specific" | "all">(
     restoredEnrollmentAccess?.installChoice ?? (requestedAgentId ? "specific" : "all"),
@@ -633,6 +637,7 @@ export function ConnectionSetupFlow({
   const [hydratedResumeConnectionId, setHydratedResumeConnectionId] = useState<string | null>(null);
   const oauthPopupRef = useRef<Window | null>(null);
   const [dialogOAuthConnectionId, setDialogOAuthConnectionId] = useState<string | null>(null);
+  const [authorizationFallbackUrl, setAuthorizationFallbackUrl] = useState<string | null>(null);
   const oauthHandoffAbortRef = useRef<AbortController | null>(null);
   const [showConnectionChoice, setShowConnectionChoice] = useState(
     existingConnections.length > 0 && Boolean(onUseExisting),
@@ -655,10 +660,11 @@ export function ConnectionSetupFlow({
       navigateTopLevel(url);
       return;
     }
+    setAuthorizationFallbackUrl(url);
     const popup = oauthPopupRef.current;
     if (!popup || popup.closed) {
       setOAuthPhase("error");
-      setOAuthError("Paperclip couldn’t open the sign-in window. Allow popups for this site and try again.");
+      setOAuthError("Paperclip couldn’t open the sign-in window. Open sign-in in a new tab to continue.");
       onPhaseChange?.("needs_retry");
       return;
     }
@@ -666,6 +672,27 @@ export function ConnectionSetupFlow({
     popup.focus();
   }, [host, onPhaseChange]);
 
+  const openAuthorizationTab = useCallback(() => {
+    // Let a real link own navigation. Some embedded browsers return a window
+    // proxy from window.open without opening a usable authorization tab.
+    oauthPopupRef.current = null;
+    setOAuthError(null);
+    setOAuthPhase("redirecting");
+    onPhaseChange?.("authorizing");
+  }, [onPhaseChange]);
+
+  useEffect(() => {
+    if (host !== "dialog" || oauthPhase !== "redirecting") return;
+    const timer = window.setInterval(() => {
+      if (!oauthPopupRef.current?.closed) return;
+      setOAuthPhase("error");
+      setOAuthError("The sign-in window closed. If authorization did not finish, try again.");
+      setAuthorizationFallbackUrl(null);
+      onPhaseChange?.("needs_retry");
+    }, 1_000);
+    return () => window.clearInterval(timer);
+  }, [host, oauthPhase, onPhaseChange]);
+
   const prepareAndOpenOAuth = useCallback(async (
     start: Pick<ToolOAuthStartResult, "authorizationUrl" | "handoff">,
   ) => {
@@ -703,11 +730,15 @@ export function ConnectionSetupFlow({
     const receiveOAuthOutcome = (event: MessageEvent) => {
       const outcome = readConnectionIntentOAuthOutcome(event, window.location.origin, connectionIntentId);
       if (outcome === "connected") {
+        setOAuthPhase("entry");
+        setAuthorizationFallbackUrl(null);
         onComplete?.({ resolvedByCallback: true });
         return;
       }
       if (outcome === "declined") {
-        onOAuthDeclined?.();
+        setOAuthPhase("error");
+        setOAuthError("Authorization was cancelled. You can try again.");
+        onPhaseChange?.("needs_retry");
         return;
       }
       if (outcome !== "failed") return;
@@ -817,7 +848,7 @@ export function ConnectionSetupFlow({
     setConnectResult(null);
     setInstallAgentIds(new Set(requestedAgentId ? [requestedAgentId] : []));
     setInstallChoice(requestedAgentId ? "specific" : "all");
-    setGrantKind(reconnectGrantKind ?? defaultGrantKindFor(initialMethod));
+    setGrantKind(reconnectGrantKind ?? defaultGrantKindFor(initialMethod, Boolean(requestedAgentId)));
     setStep("access");
     navigate(
       credentialSource === "vercel_connect"
@@ -957,6 +988,20 @@ export function ConnectionSetupFlow({
       : null,
     [connectionsQuery.data, reconnectConnectionId],
   );
+  const seededReconnectEndpoint = useRef<string | null>(null);
+  useEffect(() => {
+    // Task choices contain selection metadata only. Load the endpoint through
+    // the existing authorized connection query, once, without overwriting edits.
+    if (!configuredConnection || !connectionsQuery.isFetchedAfterMount || !reconnectConnection
+      || seededReconnectEndpoint.current === reconnectConnection.id) return;
+    const endpoint = reconnectConnection.config?.url
+      ?? reconnectConnection.transportConfig?.url
+      ?? reconnectConnection.transportConfig?.serverUrl
+      ?? reconnectConnection.config?.serverUrl;
+    if (typeof endpoint !== "string" || !/^https?:\/\//i.test(endpoint)) return;
+    seededReconnectEndpoint.current = reconnectConnection.id;
+    setLinkUrl((current) => current || endpoint);
+  }, [configuredConnection, connectionsQuery.isFetchedAfterMount, reconnectConnection]);
   const reconnectApplication = useMemo(
     () => reconnectConnection
       ? (applicationsQuery.data?.applications ?? []).find(
@@ -1073,11 +1118,14 @@ export function ConnectionSetupFlow({
    * apply the same selection.
    */
   const applyAccessInstalls = async (connectionId: string) => {
+    // The task completion endpoint adds the requester atomically with resolution.
+    if (requestedAgentId) return;
     const dedicatedIdentity = (fixedGrantKind ?? grantKind) === "agent";
     const installState = !dedicatedIdentity && installChoice === "all"
       ? { onAll: true, agentIds: new Set<string>() }
       : { onAll: false, agentIds: installAgentIds };
-    await toolsApi.putConnectionInstalls(connectionId, installPayload(selectedCompanyId!, installState));
+    const desired = installPayload(selectedCompanyId!, installState);
+    await toolsApi.putConnectionInstalls(connectionId, desired);
   };
 
   const effectiveGrantKind = fixedGrantKind ?? grantKind;
@@ -1119,7 +1167,7 @@ export function ConnectionSetupFlow({
               ? configValues
               : undefined,
           applicationId: prefill.applicationId,
-          ...(resumeConnectionId ? { resumeConnectionId } : {}),
+          ...(resumeConnectionId ? { resumeConnectionId } : reconnectConnectionId ? { reconnectConnectionId } : {}),
           ...(requestedGrantKind !== "organization" ? { grantKind: requestedGrantKind } : {}),
           ...(requestedGrantKind === "agent" ? { subjectAgentId: [...installAgentIds][0] } : {}),
         });
@@ -1140,6 +1188,7 @@ export function ConnectionSetupFlow({
         );
         result = await toolsApi.connectApp(selectedCompanyId!, {
           ...genericPayload,
+          ...(reconnectConnectionId ? { reconnectConnectionId } : {}),
           // Zapier issues a credential-bearing URL, so its branded setup keeps
           // the compact pasted-URL step. It is still a curated app, though: the
           // gallery identity must reach the server or Browse can only see a
@@ -1349,7 +1398,7 @@ export function ConnectionSetupFlow({
       const matchingEnrollmentAccess = restoredEnrollmentAccess?.companyId === selectedCompanyId
         ? restoredEnrollmentAccess
         : null;
-      setGrantKind(reconnectGrantKind ?? matchingEnrollmentAccess?.grantKind ?? defaultGrantKindFor(initialMethod));
+      setGrantKind(reconnectGrantKind ?? matchingEnrollmentAccess?.grantKind ?? defaultGrantKindFor(initialMethod, Boolean(requestedAgentId)));
       setInstallAgentIds(new Set(
         matchingEnrollmentAccess?.agentIds ?? (requestedAgentId ? [requestedAgentId] : []),
       ));
@@ -1521,6 +1570,7 @@ export function ConnectionSetupFlow({
         enabledCatalogEntryIds: enabledIds,
         askFirstCatalogEntryIds: askFirstIds,
         access: selection,
+        ...(requestedAgentId ? { preserveExistingAccess: true } : {}),
       });
       await applyAccessInstalls(connected.connectionId);
       return finished;
@@ -1724,7 +1774,7 @@ export function ConnectionSetupFlow({
         ) : null}
         <div className="mt-5 flex flex-wrap gap-2">
           <Button type="button" variant="outline" onClick={() => setShowConnectionChoice(false)}>
-            Connect new
+            {configuredConnection ? "Review connection setup" : "Connect new"}
           </Button>
           {onCancel ? <Button type="button" variant="ghost" onClick={onCancel}>Cancel</Button> : null}
         </div>
@@ -1770,6 +1820,8 @@ export function ConnectionSetupFlow({
           managementUrl: githubManagementUrl,
         } : undefined}
         authorizationHost={authorizationHost}
+        authorizationUrl={authorizationFallbackUrl}
+        onOpenAuthorization={openAuthorizationTab}
         onRetry={async () => {
           setOAuthError(null);
           setOAuthPhase("starting");
@@ -1857,6 +1909,8 @@ export function ConnectionSetupFlow({
         phase={oauthPhase}
         error={oauthError}
         authorizationHost={authorizationHost}
+        authorizationUrl={authorizationFallbackUrl}
+        onOpenAuthorization={openAuthorizationTab}
         onRetry={() => {
           setOAuthError(null);
           const connection = connectResult?.connection;
@@ -1969,6 +2023,7 @@ export function ConnectionSetupFlow({
       {step === "gallery" && (
         <GalleryStep
           loading={galleryQuery.isLoading}
+          initialLink={linkUrl}
           apps={credentialSourceApps}
           vercelConnect={vercelConnectMode}
           vercelConnectAvailability={galleryQuery.data?.credentialSources?.vercelConnect ?? null}
@@ -1987,9 +2042,9 @@ export function ConnectionSetupFlow({
             setCredentials({});
             setGoogleSheetsLinks("");
             setGoogleSheetsError(null);
-            setInstallAgentIds(new Set());
-            setInstallChoice("all");
-            setGrantKind(reconnectGrantKind ?? "organization");
+            setInstallAgentIds(new Set(requestedAgentId ? [requestedAgentId] : []));
+            setInstallChoice(requestedAgentId ? "specific" : "all");
+            setGrantKind(reconnectGrantKind ?? (requestedAgentId ? "user" : "organization"));
             setStep("access");
           }}
         />
@@ -2058,6 +2113,7 @@ export function ConnectionSetupFlow({
       ) : step === "key" && entry ? (
         <KeyStep
           entry={entry}
+          error={connectMutation.isError ? (connectMutation.error instanceof Error ? connectMutation.error.message : "Please check your key and try again.") : null}
           values={credentials}
           onChange={setCredentials}
           oauthClientId={curatedOAuthClientId}
@@ -2072,7 +2128,7 @@ export function ConnectionSetupFlow({
           onMethodChange={(nextMethod) => {
             setConnectionMethodKey(nextMethod?.key ?? "");
             if (!reconnectGrantKind) {
-              setGrantKind(defaultGrantKindFor(nextMethod));
+              setGrantKind(defaultGrantKindFor(nextMethod, Boolean(requestedAgentId)));
             }
             setCredentials({});
             setCuratedOAuthClientId("");
@@ -2223,7 +2279,7 @@ export function ConnectionSetupFlow({
       )}
 
       {step === "success" && (
-        <SuccessStep
+        <ConnectionSetupCompletionScreen
           appName={appName}
           logoUrl={entry?.branding.logoUrl}
           darkLogoUrl={entry?.branding.darkLogoUrl}
@@ -2307,7 +2363,9 @@ export function OAuthConnectStateScreen({
   error,
   recoveryActions,
   authorizationHost,
+  authorizationUrl,
   onRetry,
+  onOpenAuthorization,
   onBack,
   onCancel,
 }: {
@@ -2326,6 +2384,9 @@ export function OAuthConnectStateScreen({
    * they are being handed to (PAP-17099).
    */
   authorizationHost?: string | null;
+  /** Already validated by prepareOAuthNavigation; used for a native browser link. */
+  authorizationUrl?: string | null;
+  onOpenAuthorization?: () => void;
   onRetry: () => void;
   onBack: () => void;
   onCancel: () => void;
@@ -2419,6 +2480,7 @@ export function OAuthConnectStateScreen({
               {phase === "redirecting" ? `Opening ${serverName}…` : "Preparing…"}
             </Button>
           )}
+          {authorizationUrl ? <Button variant="outline" asChild><a href={authorizationUrl} target="_blank" rel="noopener noreferrer" onClick={onOpenAuthorization}>Open sign-in in a new tab</a></Button> : null}
           <Button type="button" variant="ghost" onClick={onBack}>Back</Button>
         </div>
       </div>
@@ -2480,6 +2542,7 @@ function ZapierConnectStep({
 
 function GalleryStep({
   loading,
+  initialLink = "",
   apps,
   byo = false,
   byoOnly = false,
@@ -2490,6 +2553,7 @@ function GalleryStep({
   onUseLink,
 }: {
   loading: boolean;
+  initialLink?: string;
   apps: AppDefinition[];
   /** Entered via the "Connect your own MCP server" card (PAP-12371, Finding C): focus the link path. */
   byo?: boolean;
@@ -2507,7 +2571,11 @@ function GalleryStep({
   onUseLink: (link: string) => void;
 }) {
   const [search, setSearch] = useState("");
-  const [linkInput, setLinkInput] = useState("");
+  const [linkInput, setLinkInput] = useState(initialLink);
+  const linkInputEdited = useRef(false);
+  useEffect(() => {
+    if (!linkInputEdited.current) setLinkInput(initialLink);
+  }, [initialLink]);
   const [linkError, setLinkError] = useState<string | null>(null);
   const linkSectionRef = useRef<HTMLDivElement>(null);
   const linkInputRef = useRef<HTMLInputElement>(null);
@@ -2707,6 +2775,7 @@ function GalleryStep({
               aria-label="MCP server URL"
               value={linkInput}
               onChange={(e) => {
+                linkInputEdited.current = true;
                 setLinkInput(e.target.value);
                 setLinkError(null);
               }}
@@ -3068,6 +3137,7 @@ function SegmentedOption({
 
 function KeyStep({
   entry,
+  error,
   values,
   onChange,
   oauthClientId,
@@ -3090,6 +3160,7 @@ function KeyStep({
   onConnect,
 }: {
   entry: AppDefinition;
+  error?: string | null;
   values: Record<string, string>;
   onChange: (next: Record<string, string>) => void;
   oauthClientId: string;
@@ -3377,6 +3448,8 @@ function KeyStep({
           </div>
         ) : null}
 
+        {error ? <div role="alert"><InlineBanner tone="danger">{error}</InlineBanner></div> : null}
+
         {standardConfigFields.map((field) => (
           <MethodConfigField
             key={field.key}
@@ -3440,6 +3513,7 @@ function KeyStep({
               </label>
               <Input
                 type="password"
+                aria-label={credentialFieldLabel(entry.name, field.label, fields.length)}
                 autoComplete="off"
                 value={values[field.configPath] ?? ""}
                 onChange={(e) => onChange({ ...values, [field.configPath]: e.target.value })}
@@ -3978,7 +4052,7 @@ function Radio({ selected }: { selected: boolean }) {
   );
 }
 
-function SuccessStep({
+export function ConnectionSetupCompletionScreen({
   appName,
   logoUrl,
   darkLogoUrl,

ui/src/pages/DesignGuide.tsx

@@ -2144,6 +2144,9 @@ export function DesignGuide() {
           The task card is the dialog host for the shared connection setup flow. Provider forms,
           validation, OAuth, access selection, and completion come from the same feature module as
           the full-page Apps setup; this card owns only audience, dialog, and task refresh behavior.
+          Pending connections stay in the timeline beside a usable composer. The independently
+          addressable Connections/In-task connections stories cover access, OAuth recovery, narrow
+          layouts, completion, and historical outcomes.
         </p>
         <div className="grid gap-4 xl:grid-cols-3">
           <IssueThreadInteractionCard

ui/src/pages/apps/AppsConnect.test.tsx

@@ -310,6 +310,44 @@ describe("AppsConnect — Connect with a link (M4 frame)", () => {
     expect(document.activeElement).toBe(urlInput);
   });
 
+  it.each(["config-url", "transport-url", "transport-serverUrl"] as const)("reloads a generic task reconnect endpoint from %s with selection-only card metadata", async (source) => {
+    const endpoint = "https://archive.example.test/mcp";
+    const choice = { id: "conn-archive", applicationId: "app-archive", name: "Archive", status: "active" as const, enabled: true };
+    listApplicationsMock.mockResolvedValue({ applications: [{ id: choice.applicationId, name: "Archive", applicationKey: "archive", type: "mcp_http" }] });
+    listConnectionsMock.mockResolvedValue({ connections: [{
+      ...choice, companyId: "company-1", transport: "mcp_remote", authKind: "none", credentialPolicy: "shared", credentialSource: "paperclip_vault",
+      config: source === "config-url" ? { url: endpoint } : {},
+      transportConfig: source === "transport-url" ? { url: endpoint } : source === "transport-serverUrl" ? { serverUrl: endpoint } : {},
+    }] });
+    await render(undefined, false, <ConnectionSetupFlow host="dialog" configuredConnection={choice} requestedAgentId="agent-1" />);
+    const input = container.querySelector<HTMLInputElement>('input[aria-label="MCP server URL"]');
+    expect(input?.value).toBe(endpoint);
+    expect(listConnectionsMock).toHaveBeenCalledWith("company-1");
+    await act(async () => { buttonByText("Continue")?.dispatchEvent(new MouseEvent("click", { bubbles: true })); });
+    await flushReact();
+    await passAccessStep();
+    await act(async () => { buttonByText("Check link")?.dispatchEvent(new MouseEvent("click", { bubbles: true })); });
+    await flushReact();
+    expect(connectAppMock).toHaveBeenCalledWith("company-1", expect.objectContaining({
+      link: endpoint, reconnectConnectionId: choice.id,
+    }));
+  });
+
+  it("preserves an edited task reconnect endpoint after refreshing connection data", async () => {
+    const choice = { id: "conn-archive", applicationId: "app-archive", name: "Archive", status: "active" as const, enabled: true };
+    const client = new QueryClient({ defaultOptions: { queries: { retry: false } } });
+    listApplicationsMock.mockResolvedValue({ applications: [{ id: choice.applicationId, name: "Archive", applicationKey: "archive", type: "mcp_http" }] });
+    listConnectionsMock.mockResolvedValue({ connections: [{ ...choice, companyId: "company-1", transport: "mcp_remote", authKind: "none", credentialPolicy: "shared", credentialSource: "paperclip_vault", config: { url: "https://archive.example.test/mcp" } }] });
+    await render(client, false, <ConnectionSetupFlow host="dialog" configuredConnection={choice} requestedAgentId="agent-1" />);
+    const input = container.querySelector<HTMLInputElement>('input[aria-label="MCP server URL"]');
+    expect(input?.value).toBe("https://archive.example.test/mcp");
+    await act(async () => setInputValue(input!, "https://edited.example.test/mcp"));
+    listConnectionsMock.mockResolvedValue({ connections: [{ ...choice, companyId: "company-1", transport: "mcp_remote", authKind: "none", credentialPolicy: "shared", credentialSource: "paperclip_vault", config: { url: "https://refreshed.example.test/mcp" } }] });
+    await act(async () => { await client.invalidateQueries(); });
+    await flushReact();
+    expect(container.querySelector<HTMLInputElement>('input[aria-label="MCP server URL"]')?.value).toBe("https://edited.example.test/mcp");
+  });
+
   it("an unrecognized URL routes to a minimal frame with the URL and key choice", async () => {
     await render();
     await gotoLinkFrame(container, "https://www.example.com/actions");
@@ -1491,9 +1529,13 @@ describe("AppsConnect — Connect with a link (M4 frame)", () => {
     await flushReact();
     await flushReact();
 
-    expect(container.textContent).toContain("Allow popups for this site and try again");
+    expect(container.textContent).toContain("Open sign-in in a new tab to continue");
     expect(container.textContent).toContain("Try again");
     expect(onPhaseChange).toHaveBeenCalledWith("needs_retry");
+    const fallback = container.querySelector<HTMLAnchorElement>('a[target="_blank"]');
+    expect(fallback?.textContent).toBe("Open sign-in in a new tab");
+    expect(fallback?.href).toContain("https://mcp.notion.com/authorize");
+    expect(fallback?.rel).toBe("noopener noreferrer");
 
     openSpy.mockRestore();
     await act(async () => dialogRoot.unmount());

ui/storybook/stories/in-feed-connections.stories.tsx

@@ -0,0 +1,240 @@
+import { useMemo, useEffect, useState } from "react";
+import { addons } from "storybook/preview-api";
+import type { Meta, StoryObj } from "@storybook/react-vite";
+import { QueryClient, QueryClientProvider, useQuery } from "@tanstack/react-query";
+import { expect, userEvent, within, waitFor } from "storybook/test";
+import { CONNECTABLE_APP_DEFINITIONS, type ConnectionIntentInteraction, type ToolConnection } from "@paperclipai/shared";
+import { ConnectionIntentInteractionBody } from "@/features/connections/ConnectionIntentInteractionBody";
+import { ConnectionSetupFlow, ConnectionSetupCompletionScreen, AccessStep, OAuthConnectStateScreen, type OAuthConnectPhase } from "@/features/connections/ConnectionSetupFlow";
+import { Dialog, DialogContent, DialogTitle } from "@/components/ui/dialog";
+import { TaskChatComposer } from "@/components/task-chat/TaskChatComposer";
+import { useNavigate } from "@/lib/router";
+import {
+  pendingConnectionIntentInteraction as pending,
+  authorizingConnectionIntentInteraction as authorizing,
+  retryConnectionIntentInteraction as retry,
+  connectedConnectionIntentInteraction as connected,
+  declinedConnectionIntentInteraction as declined,
+  expiredConnectionIntentInteraction as expired,
+  supersededConnectionIntentInteraction as superseded,
+} from "@/fixtures/issueThreadInteractionFixtures";
+
+const notion = CONNECTABLE_APP_DEFINITIONS.find((app) => app.slug === "notion")!;
+const connection = {
+  id: "11111111-1111-4111-8111-111111111119", companyId: pending.companyId,
+  applicationId: "11111111-1111-4111-8111-111111111118", name: "My Notion workspace",
+  uid: "notion/storybook", transport: "mcp_remote", authKind: "oauth", status: "active",
+  enabled: true, healthStatus: "ok", credentialPolicy: "per_user",
+  config: { sourceTemplateKey: "notion" }, transportConfig: { sourceTemplateKey: "notion" },
+  connectionKind: "managed", ownership: "customer", credentialSource: "paperclip_vault",
+  credentialSecretRefs: [], healthCheckedAt: null, lastError: null,
+  createdByAgentId: null, createdByUserId: "user-board", createdAt: new Date("2026-09-07"), updatedAt: new Date("2026-09-07"),
+} satisfies ToolConnection;
+
+type Scenario = { checking?: boolean; count?: number; loading?: boolean; loadError?: boolean; completeError?: boolean; submitting?: boolean; denied?: boolean };
+const meta: Meta = {
+  title: "Connections/In-task connections",
+  parameters: { layout: "padded" },
+  afterEach: ({ id }) => { document.body.dataset.inFeedStoryReady = id; },
+  beforeEach: ({ parameters }) => {
+    delete document.body.dataset.inFeedStoryReady;
+    delete document.body.dataset.inFeedStoryError;
+    const channel = addons.getChannel();
+    const reportPlayError = (error: unknown) => { document.body.dataset.inFeedStoryError = JSON.stringify(error); };
+    channel.on("playFunctionThrewException", reportPlayError);
+    channel.on("unhandledErrorsWhilePlaying", reportPlayError);
+    const original = window.fetch;
+    const scenario = (parameters.connectionScenario ?? {}) as Scenario;
+    let current = structuredClone(pending);
+    window.fetch = async (input, init) => {
+      const url = new URL(typeof input === "string" ? input : input instanceof URL ? input.href : input.url, window.location.origin);
+      if (url.pathname.endsWith("/tools/gallery")) return Response.json({
+        apps: CONNECTABLE_APP_DEFINITIONS.filter((app) => ["notion", "github", "posthog", "zapier"].includes(app.slug)),
+        capabilities: { canCreateOrganizationGrant: true, canSetCompanyInstall: true },
+      });
+      if (url.pathname.endsWith("/agents")) return Response.json([{ id: pending.payload.requestingAgentId, companyId: pending.companyId, name: pending.payload.requestingAgentName, status: "active", adapterType: "paperclip_runner", role: "researcher" }]);
+      if (url.pathname.startsWith("/api/connection-intents/")) {
+        if (url.pathname.endsWith("setup-options")) {
+          if (scenario.loading) return new Promise<Response>(() => {});
+          if (scenario.loadError) return Response.json({ error: "Connection options are temporarily unavailable. Try again." }, { status: 503 });
+          return Response.json({ version: 1, interaction: current, requestedAgentId: pending.payload.requestingAgentId,
+            service: { service: "notion", name: "Notion", state: "available", methods: [] },
+            existingConnections: Array.from({ length: scenario.count ?? 0 }, (_, i) => ({ ...connection, id: `${connection.id.slice(0, -1)}${i}`, name: i ? "Team Notion workspace" : connection.name })),
+          });
+        }
+        if (scenario.submitting) return new Promise<Response>(() => {});
+        if (scenario.completeError || scenario.denied) return Response.json({ error: scenario.denied ? "You no longer have permission to share this connection." : "Connection has no permitted tools. Review action permissions and try again." }, { status: scenario.denied ? 403 : 409 });
+        if (url.pathname.endsWith("decline")) current = { ...declined, id: pending.id };
+        else if (url.pathname.endsWith("complete")) current = { ...connected, id: pending.id };
+        else if (url.pathname.endsWith("phase")) current = { ...current, payload: { ...current.payload, phase: "needs_retry" } };
+        return Response.json(current);
+      }
+      // Stories never navigate to authorization or call a real provider.
+      if (init?.method && !["GET", "HEAD"].includes(init.method.toUpperCase()) && url.pathname.includes("/tools/")) {
+        if (scenario.checking) return new Promise<Response>(() => {});
+        return Response.json({ error: "Fixture connection could not be verified. Correct the setup and try again." }, { status: 422 });
+      }
+      return original(input, init);
+    };
+    return () => { window.fetch = original; channel.off("playFunctionThrewException", reportPlayError); channel.off("unhandledErrorsWhilePlaying", reportPlayError); };
+  },
+};
+export default meta;
+type Story = StoryObj<typeof meta>;
+
+function Card({ interaction = pending, otherUser = false }: { interaction?: ConnectionIntentInteraction; otherUser?: boolean }) {
+  const { data } = useQuery({ queryKey: ["issues", "interactions", interaction.id], initialData: [interaction], enabled: false, queryFn: async () => [interaction] });
+  return <ConnectionIntentInteractionBody interaction={data[0]!} currentUserId={otherUser ? "another-user" : pending.addresseeUserId} addresseeLabel="Alex" />;
+}
+function Host({ children }: { children: React.ReactNode }) {
+  const client = useMemo(() => new QueryClient({ defaultOptions: { queries: { retry: false, refetchOnWindowFocus: false }, mutations: { retry: false } } }), []);
+  return <QueryClientProvider client={client}><div className="mx-auto max-w-3xl space-y-4">{children}</div></QueryClientProvider>;
+}
+const card = (interaction = pending, scenario: Scenario = {}): Story => ({ parameters: { connectionScenario: scenario }, render: () => <Host><Card interaction={interaction} /></Host> });
+const openDialog: Story["play"] = async ({ canvasElement }) => {
+  await userEvent.click(await within(canvasElement).findByRole("button", { name: /^Connect/ }));
+  await expect(within(document.body).getByRole("dialog")).toBeVisible();
+};
+const setup = (scenario: Scenario): Story => ({ ...card(pending, scenario), play: openDialog });
+const reuse: Story["play"] = async (context) => {
+  await openDialog!(context);
+  await userEvent.click(await within(document.body).findByRole("button", { name: /My Notion workspace/ }));
+};
+
+export const NewConnection = card();
+export const EligibleReuse = card(pending, { count: 1 });
+export const Authorizing = card(authorizing);
+export const RetryRequired = card(retry);
+export const Connected = card(connected);
+export const Declined = card(declined);
+export const Expired = card(expired);
+export const Superseded = card(superseded);
+export const WaitingForAnotherUser: Story = { render: () => <Host><Card otherUser /></Host> };
+export const SetupLoading = setup({ loading: true });
+export const SetupLoadFailure = setup({ loadError: true });
+export const SetupNoExistingConnections = setup({ count: 0 });
+export const SetupOneConnection = setup({ count: 1 });
+export const SetupMultipleConnections = setup({ count: 2 });
+export const Submitting: Story = { ...setup({ count: 1, submitting: true }), play: reuse };
+export const ResolutionError: Story = { ...setup({ count: 1, completeError: true }), play: reuse };
+export const PermissionDenied: Story = { ...setup({ count: 1, denied: true }), play: reuse };
+export const ReuseAndReturnFocus: Story = { ...setup({ count: 1 }), play: async (context) => {
+  await reuse!(context);
+  await expect(within(document.body).queryByRole("dialog")).not.toBeInTheDocument();
+  await waitFor(() => expect(within(context.canvasElement).getByTestId("connection-intent-focus-target")).toHaveFocus());
+}};
+export const CloseAndReopen: Story = { ...setup({ count: 1 }), play: async (context) => {
+  await openDialog!(context);
+  await userEvent.keyboard("{Escape}");
+  await openDialog!(context);
+}};
+
+const oauth = (phase: OAuthConnectPhase, error?: string, fallback = false): Story => ({ render: () => <Host><OAuthConnectStateScreen entry={notion} phase={phase} error={error} authorizationHost="mcp.notion.com" onRetry={() => {}} onBack={() => {}} onCancel={() => {}} authorizationUrl={fallback ? "#offline-authorization" : undefined} onOpenAuthorization={fallback ? () => {} : undefined} /></Host> });
+export const OAuthEntry = oauth("entry");
+export const OAuthStarting = oauth("starting");
+export const OAuthWindowOpen = oauth("redirecting");
+export const OAuthPopupBlocked = oauth("error", "The sign-in window could not open. Continue in a new tab.", true);
+export const OAuthWindowClosed = oauth("error", "The sign-in window closed. Try again when you are ready.");
+export const OAuthCallbackFailure = oauth("error", "Authorization did not finish. Your connection is saved; try again.");
+export const OAuthRetry = oauth("error", "The provider is temporarily unavailable. Try again.");
+export const OAuthCompleted = card(connected);
+
+function FlowHost({ service, stage, dialog, extra }: { service?: string; stage: string; dialog: boolean; extra: string }) {
+  const navigate = useNavigate();
+  const [ready, setReady] = useState(false);
+  useEffect(() => {
+    navigate(`/apps/connect?${service ? `source=${service}&` : ""}stage=${stage}${extra}`, { replace: true });
+    setReady(true);
+  }, [navigate, service, stage, extra]);
+  if (!ready) return null;
+  const body = <ConnectionSetupFlow host={dialog ? "dialog" : "page"} serviceSlug={service} requestedAgentId={dialog ? pending.payload.requestingAgentId : undefined} onCancel={() => {}} />;
+  return <Host>{dialog ? <Dialog open><DialogContent className="!max-w-(--pct-90) max-h-(--sz-85vh) w-full overflow-y-auto sm:max-w-5xl"><DialogTitle>Connect an app</DialogTitle>{body}</DialogContent></Dialog> : body}</Host>;
+}
+const flow = (service: string | undefined, stage: string, dialog = false, extra = ""): Story => ({ render: () => <FlowHost service={service} stage={stage} dialog={dialog} extra={extra} /> });
+export const ProviderSelectionPage = flow(undefined, "gallery");
+export const ProviderSelectionDialog = flow(undefined, "gallery", true);
+export const RequestingAgentAccess = flow("notion", "access", true);
+export const PersonalIdentity = flow("notion", "access", true);
+export const OrganizationIdentity = flow("notion", "access");
+export const GitHubAccessPage = flow("github", "access");
+export const GitHubAccessDialog = flow("github", "access", true);
+const chooseApiKey = async () => {
+  await userEvent.click(await within(document.body).findByRole("radio", { name: "Use a personal API key" }));
+  await expect(within(document.body).getByLabelText("Your PostHog key")).toBeVisible();
+};
+export const ApiKeyFieldsPage: Story = { ...flow("posthog", "setup"), play: chooseApiKey };
+export const ApiKeyFieldsDialog: Story = { ...flow("posthog", "setup", true), play: chooseApiKey };
+const customSetup: Story["play"] = async () => {
+  const body = within(document.body);
+  await userEvent.type(await body.findByPlaceholderText("https://example.com/actions"), "https://mcp.example.invalid/mcp");
+  await userEvent.click(body.getByRole("button", { name: "Continue" }));
+  await userEvent.click(await body.findByRole("button", { name: "Save and continue" }));
+  await expect(body.getByRole("button", { name: /Check link/i })).toBeVisible();
+};
+export const CustomMcpPage: Story = { ...flow(undefined, "gallery", false, "&byo=1"), play: customSetup };
+export const CustomMcpDialog: Story = { ...flow(undefined, "gallery", true), play: customSetup };
+export const MissingLogo = card({ ...pending, payload: { ...pending.payload, serviceName: "Research archive", serviceLogoUrl: null } });
+export const LongNames = card({ ...pending, payload: { ...pending.payload, serviceName: "International product research and customer feedback archive", requestingAgentName: "Customer insights and market intelligence researcher" } });
+export const NarrowCard: Story = { ...card(), globals: { viewport: { value: "mobile1", isRotated: false } } };
+export const NarrowSetup: Story = { ...setup({ count: 2 }), globals: { viewport: { value: "mobile1", isRotated: false } } };
+export const ScrollableConnections = setup({ count: 12 });
+export const LongError = oauth("error", "This workspace requires an administrator to enable integrations before you can connect your identity. Ask your workspace administrator to enable access, then return to this task and try connecting again. Your task and previous setup choices remain available.");
+
+function Feed({ multiple = false, resolved = false, progress = false }: { multiple?: boolean; resolved?: boolean; progress?: boolean }) {
+  return <Host><p>Find our launch notes and summarize the decisions.</p><Card interaction={resolved ? connected : pending} />{multiple ? <Card interaction={{ ...pending, id: "github-request", payload: { ...pending.payload, serviceSlug: "github", serviceName: "GitHub" } }} /> : null}{progress ? <p>I can organize the release checklist while you connect Notion.</p> : null}{resolved ? <p>I found the launch notes. The team approved the staged rollout and assigned the support handoff.</p> : null}<TaskChatComposer onAdd={() => {}} workMode="standard" /></Host>;
+}
+export const PendingWithComposer: Story = { render: () => <Feed />, play: async ({ canvasElement }) => {
+  const input = within(canvasElement).getByRole("textbox");
+  await userEvent.type(input, "While I connect, organize the checklist.");
+  await expect(input).toHaveTextContent("While I connect");
+}};
+export const IndependentProgress: Story = { render: () => <Feed progress /> };
+export const MultipleRequests: Story = { render: () => <Feed multiple /> };
+export const ConnectedAndResumed: Story = { render: () => <Feed resolved /> };
+export const HistoricalCards: Story = { render: () => <Host><Card interaction={connected} /><Card interaction={declined} /><Card interaction={expired} /></Host> };
+
+function IdentityHost({ kind = "agent", unavailable = false, loading = false }: { kind?: "agent" | "user" | "organization"; unavailable?: boolean; loading?: boolean }) {
+  const [identity, setIdentity] = useState(kind);
+  const [selected, setSelected] = useState(new Set([pending.payload.requestingAgentId]));
+  return <Host><AccessStep companyId={pending.companyId} authKind="oauth" grantKind={identity} setGrantKind={setIdentity}
+    grantKinds={["user", "agent", "organization"]} installChoice="specific" setInstallChoice={() => {}}
+    installAgentIds={selected} setInstallAgentIds={setSelected} lockedAgentId={pending.payload.requestingAgentId}
+    capabilities={{ canCreateOrganizationGrant: !unavailable, canSetCompanyInstall: !unavailable, organizationGrantReason: "Ask an administrator to enable shared identities." }}
+    identityLoading={loading} submitLabel="Continue" onBack={() => {}} onContinue={() => {}} /></Host>;
+}
+export const DedicatedAgentIdentity: Story = { render: () => <IdentityHost /> };
+export const UnavailableIdentity: Story = { render: () => <IdentityHost kind="user" unavailable /> };
+export const IdentityLoading: Story = { render: () => <IdentityHost kind="user" loading /> };
+const completion = (dialog: boolean): Story => ({ render: () => {
+  const body = <ConnectionSetupCompletionScreen appName="Notion" logoUrl={notion.branding.logoUrl} summary={[{ label: "Identity", value: "Your personal identity" }, { label: "Available to", value: "Researcher" }, { label: "Actions", value: "Read pages" }]} onDone={() => {}} />;
+  return <Host>{dialog ? <Dialog open><DialogContent><DialogTitle className="sr-only">Connection complete</DialogTitle>{body}</DialogContent></Dialog> : body}</Host>;
+}});
+export const SetupCompletionPage = completion(false);
+export const SetupCompletionDialog = completion(true);
+export const ValidationError: Story = { ...flow("posthog", "setup", true), play: async () => {
+  await chooseApiKey();
+  const dialog = within(document.body);
+  const connect = await dialog.findByRole("button", { name: "Connect" });
+  await expect(connect).toBeDisabled();
+  await userEvent.type(dialog.getByLabelText("Your PostHog key"), "fixture-invalid-key");
+  await userEvent.click(connect);
+  await expect(await dialog.findByText(/Fixture connection could not be verified/)).toBeVisible();
+}};
+export const OAuthNewTabFallback: Story = { ...oauth("error", "The sign-in window could not open. Continue in a new tab.", true), play: async ({canvasElement}) => {
+  await userEvent.click(within(canvasElement).getByRole("link", { name: "Open sign-in in a new tab" }));
+}};
+
+export const CheckingConnection: Story = { ...CustomMcpDialog, parameters: { connectionScenario: { checking: true } }, play: async (context) => {
+  await customSetup!(context);
+  await userEvent.click(within(document.body).getByRole("button", { name: /Check link/i }));
+}};
+export const SetupFailure: Story = { ...CustomMcpDialog, play: async (context) => {
+  await customSetup!(context);
+  await userEvent.click(within(document.body).getByRole("button", { name: /Check link/i }));
+  await expect(await within(document.body).findByText(/Fixture connection could not be verified/)).toBeVisible();
+}};
+export const SetupFailureRetry: Story = { ...SetupFailure, play: async (context) => {
+  await SetupFailure.play!(context);
+  await userEvent.click(within(document.body).getByRole("button", { name: /Check link/i }));
+  await expect(await within(document.body).findByText(/Fixture connection could not be verified/)).toBeVisible();
+}};