feat(integrations): add an "Add Existing Integration" picker to reuse integrations across projects - #516

…sting integration

`getCachedRoster` narrowed the cached roster to the types the panel can manage and
`attachExistingIntegration` persisted that narrowed array, so linking an integration
silently dropped `pandas-dataframe` (and any type this build does not know) from the
project's integrations. The roster now passes through verbatim, following the same
cast-not-narrow pattern `SqlCellStatusBarProvider.addToProjectIntegrations` already
uses, and only the picker's exclusion set is derived from it.

Adds a picker test and a manager test asserting a `pandas-dataframe` entry survives
the attach in both the cache update and the written file.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

Drops comments that restated the code they sat on, condenses the
docstrings that explained storage internals at tutorial length, and
states the "reuse is a link, not a copy" rationale once in
collectReusableIntegrations instead of in three places.

Also moves add_existing_integration to its alphabetical slot in
TelemetryEventProperties. It had been inserted between the
"No `outcome`: ..." docblock and refresh_integration_env, so that block
read as documenting an event that does carry an outcome.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NjAiQLqjuPiZmN9GiTXCfd

Addresses the review of this branch.

Correctness:
- Re-read the project's integrations after the QuickPick instead of writing
  back a snapshot taken before it. The file watcher replaces the cached
  project on an integrations-only external write without any UI event, so
  the pre-pick array could be stale, and the writer stamps whatever it is
  given onto every .deepnote file of the project.
- Refuse the command on a *.snapshot.deepnote file. Snapshots match the
  notebook selector and the writer skips them, so the command reported a
  failure only after it had already updated the cache.
- getCachedProjectIntegrations returns undefined on a cache miss rather than
  an empty array, so "not cached" can no longer be written back as "no
  integrations at all".
- Make the workspace scan cancellable: window.withProgress plumbs a token
  into collectReusableIntegrations, findFiles and both scan loops.

Types:
- Widen the write path to RawProjectIntegration, now defined once in
  notebooks/types.ts. This removes both `as ProjectIntegration[]` assertions
  and two duplicate local declarations of the type. Narrowing inside the
  writer is now a compile error rather than a silently exhaustive switch.

Naming:
- "roster" becomes "project integrations" throughout. In the SQL status bar
  the narrower and wider lists are now projectIntegrations and
  selectableIntegrations, matching getSelectableIntegrations.

Localization:
- Integration type labels were written out in seven places, one of which
  (the webview map) was never localized at all. They now live only in
  localize.Integrations.typeLabels, keyed by a bundle key derived from the
  integration type so there is no second list to keep in sync. Drops the
  dead integrationsDuckDBTypeLabel.

Tests:
- Cover every failure branch of addExistingIntegration, plus the stale
  re-read, the snapshot guard, the cache miss and both cancellation paths.
  Each new test was verified to fail against the unfixed code.
- Type refreshSpy off IIntegrationEnvLiveRefresher so a signature change
  fails the compile, not just the runtime assertion.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Ns2d146xs51a6E8LeDgJQS

…sting integration

Three places where the command acted on state it had not re-derived at the
moment it acted:

- The panel posts the notebook URI it was opened for, and nothing clears it
  when that notebook closes. `resolveDeepnoteNotebook` then fell through to
  the focus fallbacks, so the pick was written into whichever other project
  happened to be visible, along with its siblings and a kernel env refresh.
  Reject a supplied URI that no longer resolves; the palette path passes no
  URI and still needs the fallback.

- `persistProjectIntegrations` updates the cache before it writes, so a failed
  write left the link in the roster. The retry then excluded that id and
  reported nothing available, while the file still lacked it. Restore the
  pre-write roster on the failure branch.

- `collectReusableIntegrations` only checked the cancellation token at loop
  heads, so a cancel during the last file, or during `findFiles`, returned
  `cancelled: false`. That opened an unwanted picker and, in a single-root
  workspace, claimed no integrations were available after an unfinished scan.
  Recheck the token before assembling the result.

Each fix has a regression test that was seen to fail against the unfixed code.
The picker test harness now models `findFiles` resolving empty on a tripped
token, which is what let the scan bug go uncovered.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Ns2d146xs51a6E8LeDgJQS

…egration scan

`collectReusableIntegrations` signalled cancellation with a `cancelled` flag
alongside two fields that were always empty when it was set — a sum type
encoded as a product. The cost showed up as three identical dead literals and
two doc comments whose only job was to warn that the other fields were unsafe
to read.

It also made the failure silent by default: a caller that forgets to check the
flag proceeds on an empty roster and reports "no integrations available" after
an unfinished scan, which is the bug fixed in the previous commit. A throw
cannot be forgotten.

Use the helpers the repo already has — `Cancellation.throwIfCanceled` and
`isCancellationError` from `platform/common/cancellation`, as the kernel layer
does — so the result type is now always meaningful and both warnings are gone.
The only caller handles it in the try/catch that AGENTS.md already prescribes
around `withProgress`, and rethrows anything that is not a cancellation, which
is what happened before.

Verified by mutation: neutralising the three guards fails exactly the three
cancellation tests and nothing else.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Ns2d146xs51a6E8LeDgJQS

…tegrations namespace

Drives the real reuse flow in one temp workspace holding two fixture
projects: runs the command on "Quick Notes" while the sibling project
only declares an integration it never configured, configures a
PostgreSQL integration through the integrations panel, then reuses it
from "Sales Analytics".

Seeding goes through the panel because the picker offers only ids with a
config in SecretStorage, and the panel's Save is its one writer. A
`.deepnote.env.yaml` cannot stand in: file-only integrations are
excluded from the picker by design, since they already apply to every
project under the file.

Asserts the rules a unit test cannot reach end to end:
- a declaration without stored credentials is not offered
- the picked row carries the name, the type label and "Used in: <project>"
- the target project's file gains the link and KEEPS the integration it
  already declared
- the credentials never reach that file

Both halves were verified to fail against mutated builds: dropping the
existing entries in attachExistingIntegration fails the roster
assertion, and offering entries with no stored config fails the
"nothing to reuse" case.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Ns2d146xs51a6E8LeDgJQS

`*.snapshot.deepnote` matches the notebook selector, so the SQL cell's
integration picker is reachable on a snapshot. Switching there edited the
record's own cell metadata and, through `addToProjectIntegrations`,
rewrote the real project files behind it — the snapshot's active write is
skipped, but the sibling sweep still stamps every matching `.deepnote`.

`addExistingIntegration` has guarded this since 058fe8f; this path
never did. Guard at the top of `switchIntegration` rather than inside
`addToProjectIntegrations`, so the cell metadata edit is refused too.

The test arranges the project, the pick and the edit so the switch would
otherwise go through, leaving the snapshot check as the only thing that
can stop it; it was verified to fail with the guard disabled. An earlier
version of it passed with the guard disabled, because an unstubbed
project sent it down the "Project not found" return instead.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01Ns2d146xs51a6E8LeDgJQS