@cat-factory/app 0.235.0 → 0.236.1

package/app/composables/api/documents.ts

@@ -9,6 +9,7 @@ import {
   listDocumentsContract,
   listDocumentSourcesContract,
   planDocumentContract,
+  resolveDocumentRefContract,
   searchDocumentsContract,
   spawnDocumentContract,
   unlinkDocumentForKindContract,
@@ -48,6 +49,15 @@ export function documentsApi({ send, ws }: ApiContext) {
     listDocuments: (workspaceId: string) =>
       send(listDocumentsContract, { pathPrefix: ws(workspaceId) }),
 
+    // Canonicalise a pasted URL/id without importing it: the pre-flight the attach pickers run
+    // so an unusable link is corrected before the task that carries it is saved.
+    resolveDocumentRef: (workspaceId: string, source: DocumentSourceKind, body: { ref: string }) =>
+      send(resolveDocumentRefContract, {
+        pathPrefix: ws(workspaceId),
+        pathParams: { source },
+        body,
+      }),
+
     importDocument: (workspaceId: string, source: DocumentSourceKind, body: { ref: string }) =>
       send(importDocumentContract, { pathPrefix: ws(workspaceId), pathParams: { source }, body }),
 

package/app/composables/useAiReadiness.ts

@@ -13,9 +13,10 @@ import type { ModelPreset } from '~/types/model-presets'
  *    still points at one or more that aren't usable (⇒ the preset-mismatch prompt). Gated on
  *    `hasUsableModel` so the no-AI prompt owns the "nothing works" case on its own.
  *
- * Read-only over the existing stores; the catalog is loaded elsewhere (on workspace-ready
- * and after credential edits), so `ready` simply reports whether that load has landed for
- * the active workspace.
+ * Read-only over the existing stores; the catalog is loaded elsewhere (on the active board
+ * changing and after credential edits), so `ready` simply reports whether that load has landed
+ * for the active workspace. A load that FAILED leaves it false, which is what keeps the no-AI
+ * prompt off a board whose catalog never arrived (see `models.prefetchForBoard`).
  */
 export function useAiReadiness() {
   const models = useModelsStore()

package/app/composables/useContextLinking.spec.ts

@@ -85,6 +85,101 @@ describe('contextKey', () => {
   })
 })
 
+describe('resolvePending', () => {
+  // Fetching an attachment moved AHEAD of the create: an unreachable page is a correction the
+  // user can still make with the form open, where the same failure afterwards leaves a task
+  // carrying context it never got. These pin the two halves that makes load-bearing: what the
+  // host gets back, and that one bad attachment does not hide a second one.
+  function stub(
+    importDocument: (source: string, ref: string) => Promise<{ externalId: string }>,
+    importTask: (
+      source: string,
+      ref: string,
+    ) => Promise<{
+      externalId: string
+      description: string
+    }> = async () => ({ externalId: 'T-1', description: '' }),
+  ) {
+    vi.stubGlobal('useDocumentsStore', () => ({ importDocument }))
+    vi.stubGlobal('useTasksStore', () => ({ importTask }))
+    vi.stubGlobal('useWorkspaceStore', () => ({ workspaceId: 'ws_1' }))
+    vi.stubGlobal('useToast', () => ({ add: vi.fn() }))
+    vi.stubGlobal('useI18n', () => ({ t: (key: string) => key }))
+    vi.stubGlobal('useCopyToClipboard', () => ({ copyAction: () => ({ label: 'copy' }) }))
+  }
+
+  afterEach(() => vi.unstubAllGlobals())
+
+  it('imports what needs it and hands back items the later link can use directly', async () => {
+    stub(async (_source, ref) => ({ externalId: `resolved:${ref}` }))
+    const already = item({ externalId: 'acme/repo:docs/done.md', needsImport: false })
+
+    const { resolved, failures } = await useContextLinking().resolvePending([item(), already])
+
+    expect(failures).toEqual([])
+    // The import's own canonical id is carried forward, not the pasted ref, and the flag flips so
+    // `linkPending` links rather than re-fetching.
+    expect(resolved.map((c) => [c.externalId, c.needsImport])).toEqual([
+      ['resolved:acme/repo:docs/x.md', false],
+      ['acme/repo:docs/done.md', false],
+    ])
+  })
+
+  it('reports EVERY failure and keeps the failed item staged', async () => {
+    stub(async (_source, ref) => {
+      throw new Error(`no access to ${ref}`)
+    })
+    const a = item({ externalId: 'acme/repo:a.md' })
+    const b = item({ externalId: 'acme/repo:b.md' })
+
+    const { resolved, failures } = await useContextLinking().resolvePending([a, b])
+
+    // Both, not just the first: fixing them one round-trip at a time is the failure mode.
+    expect(failures.map((f) => f.item.externalId)).toEqual(['acme/repo:a.md', 'acme/repo:b.md'])
+    expect(failures[0]!.message).toContain('no access to acme/repo:a.md')
+    // Still staged and still unresolved: the host aborts the create, so dropping them here would
+    // silently discard attachments the user asked for while they are fixing them.
+    expect(resolved.map((c) => c.needsImport)).toEqual([true, true])
+    // And MARKED, so the form the user is still looking at names which chip refused. The toast
+    // names them too, but the toast is gone by the time they go looking for the one to remove.
+    expect(resolved.map((c) => c.unreadable)).toEqual([
+      'no access to acme/repo:a.md',
+      'no access to acme/repo:b.md',
+    ])
+  })
+
+  it('clears a stale unreadable mark once the item does resolve', async () => {
+    // A prior failure is not a standing verdict: leaving the mark on a page that has just been
+    // fetched accuses a good attachment (and the retry is the whole point of keeping it staged).
+    stub(async (_source, ref) => ({ externalId: `resolved:${ref}` }))
+    const previouslyFailed = item({ unreadable: 'GitHub denied access (HTTP 403).' })
+
+    const { resolved } = await useContextLinking().resolvePending([previouslyFailed])
+
+    expect(resolved[0]!.unreadable).toBeUndefined()
+    expect(resolved[0]!.needsImport).toBe(false)
+  })
+
+  it("carries an imported issue's description forward, not just its id", async () => {
+    // The add-task form composes the saved description from these items on the very next statement
+    // (`linkedIssueBodies`), so an import that fetched the body and dropped it produced a task
+    // silently missing the issue text it was created from, with the bytes in hand at that moment.
+    stub(
+      async (_source, ref) => ({ externalId: ref }),
+      async () => ({ externalId: 'ENG-42', description: 'Steps to reproduce: …' }),
+    )
+    const issue = item({ kind: 'task', externalId: 'ENG-42', title: 'ENG-42 · Crash' })
+
+    const { resolved } = await useContextLinking().resolvePending([issue])
+
+    expect(resolved[0]).toMatchObject({
+      externalId: 'ENG-42',
+      needsImport: false,
+      description: 'Steps to reproduce: …',
+    })
+  })
+})
+
 describe('presentLinkFailures', () => {
   // Stub the Nuxt auto-imports `useContextLinking` pulls in, so the toast-orchestration
   // side of the composable can be exercised without a full Nuxt runtime.

package/app/composables/useContextLinking.ts

@@ -29,6 +29,17 @@ export interface PendingContext {
   description?: string
   /** True when the item must be imported before it can be linked. */
   needsImport: boolean
+  /**
+   * Why this item could not be FETCHED, when an attempt has already failed (the server's own
+   * message). Set by {@link useContextLinking.resolvePending} and by the add-task form's body
+   * pre-fetch; cleared the moment a later attempt succeeds.
+   *
+   * It exists because the fetch moved ahead of the create: a failure now costs the user the
+   * create, so the item that caused it has to be identifiable ON the form they are still looking
+   * at, not only in the toast that named it. A tracker issue has no pre-flight of its own, so this
+   * is the whole of its warning.
+   */
+  unreadable?: string
 }
 
 /**
@@ -114,6 +125,70 @@ export function useContextLinking() {
   const { t } = useI18n()
   const { copyAction } = useCopyToClipboard()
 
+  /**
+   * Import every pending item that still needs it, BEFORE the block exists.
+   *
+   * The fetch against the external source is the half of attaching that actually fails (a page
+   * that moved, a token without access, a source that is down), and it needs no block id. Running
+   * it after the block was created therefore bought nothing and cost the user their chance to fix
+   * it: the task existed, carrying context it had not got. Run here, a failure is a correction
+   * the host can ask for with the form still open and the reference still editable.
+   *
+   * Returns the items with what succeeded folded in (`needsImport: false`, so the later
+   * {@link linkPending} links them directly), alongside the failures. The batch is NOT aborted on
+   * the first failure: one unreachable page must not hide a second one, or the user fixes them
+   * one round-trip at a time.
+   *
+   * What "folded in" covers is the whole point of running this before the create, so it is more
+   * than the id: a tracker issue's own DESCRIPTION arrives with the import, and the add-task form
+   * composes the saved description from exactly these items on the next statement. Keeping only
+   * the id dropped a body the platform had in hand at the one moment it was needed.
+   */
+  async function resolvePending(
+    items: PendingContext[],
+  ): Promise<{ resolved: PendingContext[]; failures: LinkFailure[] }> {
+    const failures: LinkFailure[] = []
+    const resolved: PendingContext[] = []
+    for (const item of items) {
+      if (!item.needsImport) {
+        resolved.push(item)
+        continue
+      }
+      try {
+        resolved.push(await importPending(item))
+      } catch (e) {
+        const failure = describeLinkFailure(item, e)
+        failures.push(failure)
+        // Kept in the list, still unresolved: the host aborts on any failure, and dropping the
+        // item here would silently discard an attachment the user asked for while they fix it.
+        // Marked, so the form the user is still looking at names WHICH attachment refused.
+        resolved.push({ ...item, unreadable: failure.message })
+      }
+    }
+    return { resolved, failures }
+  }
+
+  /** Fetch one pending item, folding everything the import answers back onto it. */
+  async function importPending(item: PendingContext): Promise<PendingContext> {
+    // `unreadable` is dropped rather than preserved: a prior failure is not a standing verdict, and
+    // leaving the mark on a page that has just been fetched would accuse a good attachment.
+    const { unreadable: _cleared, ...rest } = item
+    if (item.kind === 'document') {
+      const doc = await documents.importDocument(item.source as DocumentSourceKind, item.externalId)
+      return { ...rest, externalId: doc.externalId, needsImport: false }
+    }
+    const task = await tasks.importTask(item.source as TaskSourceKind, item.externalId)
+    return {
+      ...rest,
+      externalId: task.externalId,
+      needsImport: false,
+      // The body reaches the created task through the host's description composition, which reads
+      // `description` off these items: an import that fetched it and did not carry it forward is a
+      // task silently missing the issue text it was created from.
+      ...(task.description.trim() ? { description: task.description } : {}),
+    }
+  }
+
   /**
    * Import (when needed) then link every pending item to `blockId`. Each failure
    * is captured with its actual cause rather than aborting the batch, so one bad
@@ -137,25 +212,31 @@ export function useContextLinking() {
           await tasks.linkToBlock(blockId, source, externalId)
         }
       } catch (e) {
-        // Never swallow the cause: capture the server's own message + status/code/details
-        // so the toast can name the specific reason and the copy affordance can carry the
-        // full context (incl. the upstream GitHub status the backend puts on `details`).
-        const envelope = apiErrorEnvelope(e)
-        failures.push({
-          item,
-          message: e instanceof Error ? e.message : String(e),
-          status: apiErrorStatus(e),
-          code: envelope?.code,
-          details:
-            envelope?.details && typeof envelope.details === 'object'
-              ? (envelope.details as Record<string, unknown>)
-              : undefined,
-        })
+        failures.push(describeLinkFailure(item, e))
       }
     }
     return failures
   }
 
+  /**
+   * Never swallow the cause: capture the server's own message + status/code/details so the toast
+   * can name the specific reason and the copy affordance can carry the full context (incl. the
+   * upstream GitHub status the backend puts on `details`).
+   */
+  function describeLinkFailure(item: PendingContext, e: unknown): LinkFailure {
+    const envelope = apiErrorEnvelope(e)
+    return {
+      item,
+      message: e instanceof Error ? e.message : String(e),
+      status: apiErrorStatus(e),
+      code: envelope?.code,
+      details:
+        envelope?.details && typeof envelope.details === 'object'
+          ? (envelope.details as Record<string, unknown>)
+          : undefined,
+    }
+  }
+
   /**
    * Surface link failures as a single actionable toast: the specific per-item
    * reasons as the body, and a "Copy details" action that puts the full diagnostic
@@ -209,5 +290,5 @@ export function useContextLinking() {
     })
   }
 
-  return { linkPending, presentLinkFailures }
+  return { resolvePending, linkPending, presentLinkFailures }
 }

package/app/pages/index.vue

@@ -191,10 +191,16 @@ const autoOpenedPreset = ref(false)
 // availability reflects that workspace's keys/subscriptions). This populates the AI-readiness
 // signals regardless of which lazy picker happens to mount, so the onboarding prompts below
 // can fire. Credential edits re-fetch via `models.refresh()` in the provider panels.
+//
+// Through `prefetchForBoard` because the FIRST run reads the persisted pin, which `init()` has
+// not validated yet: a board that was deleted, or whose access was revoked while the browser
+// held the pin, 404s here exactly as it does for init's own speculative snapshot fetch. That
+// board is not this watcher's last word (init re-points the pin and it fires again), so the
+// miss is dropped rather than left to surface as an uncaught rejection in the page.
 watch(
   () => workspace.workspaceId,
   (id, prev) => {
-    if (id) void models.ensureLoaded(id)
+    if (id) void models.prefetchForBoard(id)
     // Switching workspaces resets the per-session AI-onboarding state: dismissals and the
     // auto-open guards are scoped to one workspace, so a prompt dismissed in workspace A must
     // not suppress the (independent) prompt for workspace B that also lacks a usable source.

package/app/stores/documents.ts

@@ -9,6 +9,7 @@ import type {
   DocumentOrigin,
   DocumentSourceDescriptor,
   DocumentSourceKind,
+  ResolvedDocumentRef,
   SourceDocument,
 } from '~/types/domain'
 import { isConnectableSource } from '@cat-factory/contracts'
@@ -82,6 +83,16 @@ export const useDocumentsStore = defineStore('documents', () => {
     documents.value = await api.listDocuments(workspace.requireId())
   }
 
+  /**
+   * Canonicalise a pasted URL/id into the reference this source would store it under, WITHOUT
+   * importing it. The backend's providers own the rule, so the picker validates against the same
+   * parse the import will run rather than a second copy of it that can drift; a ref the source
+   * cannot read comes back as a 422 whose `details.reason` says which correction it needs.
+   */
+  function resolveRef(source: DocumentSourceKind, ref: string): Promise<ResolvedDocumentRef> {
+    return api.resolveDocumentRef(workspace.requireId(), source, { ref })
+  }
+
   /** Import (fetch + persist) a page by id or URL from a source. */
   async function importDocument(source: DocumentSourceKind, ref: string): Promise<SourceDocument> {
     loading.value = true
@@ -211,6 +222,7 @@ export const useDocumentsStore = defineStore('documents', () => {
     connect,
     disconnect,
     loadDocuments,
+    resolveRef,
     importDocument,
     search,
     plan,

package/app/stores/models.spec.ts

@@ -0,0 +1,64 @@
+import { describe, it, expect, vi } from 'vitest'
+import type { ModelOption } from '~/types/domain'
+import { useModelsStore } from '~/stores/models'
+
+/** Minimal catalog entry: only the fields the store's own reads touch. */
+function model(over: Partial<ModelOption> = {}): ModelOption {
+  return {
+    id: 'qwen3',
+    label: 'Qwen3',
+    description: '',
+    flavor: 'cloudflare',
+    providerLabel: 'Cloudflare',
+    provider: 'cloudflare',
+    model: 'qwen3',
+    available: true,
+    ...over,
+  } as ModelOption
+}
+
+// The boot-time catalog load runs against the PERSISTED PIN, before `workspace.init()` has
+// validated it against the board list. A pin can name a board that was deleted, or one whose
+// access was revoked while the browser held it, and the RBAC gate answers both with a 404, so
+// the load has to tolerate a miss. Left bare it was an uncaught rejection in the page (the
+// `Workspace not found` a removed member's browser threw on their next visit).
+describe('models store: the speculative load of an unvalidated pin', () => {
+  it('drops a pin that 404s and leaves the catalog retryable for the board init resolves', async () => {
+    const get = vi
+      .fn<(workspaceId: string) => Promise<ModelOption[]>>()
+      .mockRejectedValueOnce(Object.assign(new Error('Workspace not found'), { statusCode: 404 }))
+      .mockResolvedValueOnce([model()])
+    vi.stubGlobal('useApi', () => ({ getWorkspaceModels: get }))
+
+    const store = useModelsStore()
+    // The revoked pin. Resolves rather than rejects: nothing in the page catches it.
+    await expect(store.prefetchForBoard('ws_revoked')).resolves.toBeUndefined()
+
+    // Nothing was latched, so this reads as UNRESOLVED rather than as a board with no models
+    // (`useAiReadiness().ready` is `loaded && loadedWorkspaceId === workspaceId`, which is what
+    // keeps the no-AI onboarding prompt from firing off a catalog that never landed).
+    expect(store.loaded).toBe(false)
+    expect(store.loadedWorkspaceId).toBeNull()
+    expect(store.models).toEqual([])
+
+    // ...and the board `init()` resolves instead still loads, on the same store.
+    await store.ensureLoaded('ws_reachable')
+    expect(store.loaded).toBe(true)
+    expect(store.loadedWorkspaceId).toBe('ws_reachable')
+    expect(store.models).toHaveLength(1)
+  })
+
+  it('a pin that IS reachable loads the catalog once, and the later caller reuses it', async () => {
+    const get = vi.fn(() => Promise.resolve([model()]))
+    vi.stubGlobal('useApi', () => ({ getWorkspaceModels: get }))
+
+    const store = useModelsStore()
+    await store.prefetchForBoard('ws1')
+    // What the cold open pays for: `init()` hydrating the same board finds the catalog already
+    // there, so the prefetch is one request rather than a duplicate of the one that follows it.
+    await store.ensureLoaded('ws1')
+
+    expect(get).toHaveBeenCalledTimes(1)
+    expect(store.hasUsableModel).toBe(true)
+  })
+})

package/app/stores/models.ts

@@ -122,6 +122,26 @@ export const useModelsStore = defineStore('models', () => {
     loaded.value = true
   }
 
+  /**
+   * Load the catalog for a board the app has NOT yet validated: the persisted pin at boot,
+   * fetched in parallel with the workspace list rather than after it.
+   *
+   * A pin can name a board that was deleted, or one whose access has since been revoked, and the
+   * gate answers both with a 404 (`workspace.init()` guards the same speculative read of the same
+   * id with `.catch(() => null)`). So a failure here is an expected outcome rather than a fault,
+   * and dropping it is safe in both directions: `loaded` stays false, so this leaves the catalog
+   * RETRYABLE for the next `ensureLoaded` caller, and `useAiReadiness().ready` stays false, so a
+   * catalog that never landed reads as unresolved instead of as a board with no AI configured.
+   */
+  async function prefetchForBoard(workspaceId: string): Promise<void> {
+    try {
+      await ensureLoaded(workspaceId)
+    } catch {
+      // Deliberate: see above. `init()` re-points the board it resolved, which loads the catalog
+      // that counts; anything else retries on the next caller.
+    }
+  }
+
   /** Force a re-fetch of the per-workspace catalog (e.g. after adding an API key). */
   async function refresh(workspaceId: string) {
     models.value = await api.getWorkspaceModels(workspaceId)
@@ -180,6 +200,7 @@ export const useModelsStore = defineStore('models', () => {
     loaded,
     loadedWorkspaceId,
     ensureLoaded,
+    prefetchForBoard,
     refresh,
     byId,
     getModel,

package/app/types/documents.ts

@@ -17,6 +17,8 @@ export type {
   DocumentConnection,
   SourceDocument,
   DocumentSearchResult,
+  DocumentRefReason,
+  ResolvedDocumentRef,
   PlanTask,
   PlanModule,
   PlanFrame,

package/i18n/locales/de.json

@@ -2818,7 +2818,8 @@
         "derivedTitleFallback": "Pull Request prüfen",
         "prNotFound": "Pull Request #{number} wurde im Repository dieses Service nicht gefunden. Prüfe die Nummer, oder verknüpfe den Service mit dem Repository, in dem der Pull Request liegt.",
         "prRepoMismatch": "Dieser Pull Request liegt in einem anderen Repository. Dieser Service prüft {repo}; lege die Prüfaufgabe unter dem Service an, der mit dem Repository des Pull Requests verknüpft ist."
-      }
+      },
+      "contextFailed": "Aufgabe nicht erstellt: {count} Anhang konnte nicht gelesen werden | Aufgabe nicht erstellt: {count} Anhänge konnten nicht gelesen werden"
     },
     "recurring": {
       "title": "Eine wiederkehrende Pipeline hinzufügen",
@@ -3004,7 +3005,8 @@
     "attachDocDisabledEnable": "Aktivieren Sie zuerst die Dokumente-Integration",
     "attachIssueDisabledConnect": "Verbinden Sie zuerst einen Issue-Tracker (Integrationen)",
     "attachIssueDisabledEnable": "Aktivieren Sie zuerst die Issue-Tracker-Integration",
-    "importsOnAdd": "importiert beim Hinzufügen"
+    "importsOnAdd": "importiert beim Hinzufügen",
+    "unreadable": "Konnte nicht abgerufen werden: {error}"
   },
   "providers": {
     "presetMismatch": {
@@ -3783,7 +3785,15 @@
       "attachByReference": "{ref} per Referenz anhängen",
       "noMatches": "Keine passenden Seiten.",
       "emptySearchable": "Nach Titel suchen oder ein importiertes Dokument auswählen.",
-      "emptyRefOnly": "Fügen Sie eine Seiten-URL oder -ID ein, um sie anzuhängen."
+      "emptyRefOnly": "Fügen Sie eine Seiten-URL oder -ID ein, um sie anzuhängen.",
+      "refChecking": "Referenz wird geprüft…",
+      "refUnrecognized": "Keine {source}-Referenz. Erwartet: {expected}",
+      "refOtherSource": "Das ist ein {claimed}-Link, kein {source}-Link.",
+      "refSwitchSource": "Stattdessen {source} verwenden",
+      "refTrimmed": "Auf die unterstützte Form gekürzt",
+      "refWidened": "Nennt einen Frame, den diese Quelle nicht lesen kann ({scope}); daher wird die gesamte Datei angehängt.",
+      "refAlreadyAttached": "Diese Referenz ist bereits angehängt.",
+      "refCheckFailed": "Referenz konnte nicht geprüft werden: {error}"
     },
     "repoPicker": {
       "searchRepoPlaceholder": "Repositorys suchen…",
@@ -5040,7 +5050,8 @@
       "failedTitle": "Die Initiative konnte nicht erstellt werden",
       "contextDocsHint": "Hänge eine Anforderung, ein RFC oder ein PRD an, damit die Planungsagenten es beim Abstecken und Entwerfen des Plans lesen.",
       "contextIssuesHint": "Hänge ein Tracker-Issue an, damit die Planungsagenten beim Entwerfen des Plans seine Beschreibung und Kommentare sehen.",
-      "linkFailed": "Initiative erstellt, aber {count} Anhang konnte nicht verknüpft werden | Initiative erstellt, aber {count} Anhänge konnten nicht verknüpft werden"
+      "linkFailed": "Initiative erstellt, aber {count} Anhang konnte nicht verknüpft werden | Initiative erstellt, aber {count} Anhänge konnten nicht verknüpft werden",
+      "contextFailed": "Initiative nicht erstellt: {count} Anhang konnte nicht gelesen werden | Initiative nicht erstellt: {count} Anhänge konnten nicht gelesen werden"
     },
     "status": {
       "planning": "Planung",

package/i18n/locales/en.json

@@ -347,6 +347,10 @@
         "derivedTitleFallback": "Review pull request",
         "prNotFound": "Pull request #{number} was not found in this service's repository. Check the number, or link the service to the repository that pull request is on.",
         "prRepoMismatch": "That pull request is on a different repository. This service reviews {repo}, so create the review task under the service linked to the pull request's repository."
+      },
+      "contextFailed": "Task not created: {count} attachment could not be read | Task not created: {count} attachments could not be read",
+      "@contextFailed": {
+        "description": "Count-based: how many context attachments (docs/issues) could not be fetched, which is why nothing was created (count is always >= 1). Provide ALL plural forms your language needs (English has 2; Polish/Ukrainian need 3 - one/few/many - via the custom pluralRules in i18n.config.ts)."
       }
     },
     "recurring": {
@@ -548,7 +552,8 @@
     "attachDocDisabledEnable": "Enable the documents integration first",
     "attachIssueDisabledConnect": "Connect an issue tracker first (Integrations)",
     "attachIssueDisabledEnable": "Enable the issue-tracker integration first",
-    "importsOnAdd": "imports on add"
+    "importsOnAdd": "imports on add",
+    "unreadable": "Could not be fetched: {error}"
   },
   "errors": {
     "generic": {
@@ -4300,7 +4305,15 @@
       "attachByReference": "Attach {ref} by reference",
       "noMatches": "No matching pages.",
       "emptySearchable": "Search by title, or pick an imported document.",
-      "emptyRefOnly": "Paste a page URL or ID to attach it."
+      "emptyRefOnly": "Paste a page URL or ID to attach it.",
+      "refChecking": "Checking the reference…",
+      "refUnrecognized": "Not a {source} reference. Expected {expected}",
+      "refOtherSource": "That is a {claimed} link, not a {source} one.",
+      "refSwitchSource": "Use {source} instead",
+      "refTrimmed": "Trimmed to the supported form",
+      "refWidened": "Names a frame this source cannot read ({scope}), so the whole file is attached.",
+      "refAlreadyAttached": "This reference is already attached.",
+      "refCheckFailed": "Could not check the reference: {error}"
     },
     "repoPicker": {
       "searchRepoPlaceholder": "Search repositories…",
@@ -6515,6 +6528,10 @@
       "linkFailed": "Initiative created, but {count} attachment could not be linked | Initiative created, but {count} attachments could not be linked",
       "@linkFailed": {
         "description": "Count-based: how many context attachments (docs/issues) failed to link after the initiative was created (count is always >= 1). Provide ALL plural forms your language needs (English has 2; Polish/Ukrainian need 3 - one/few/many - via the custom pluralRules in i18n.config.ts)."
+      },
+      "contextFailed": "Initiative not created: {count} attachment could not be read | Initiative not created: {count} attachments could not be read",
+      "@contextFailed": {
+        "description": "Count-based: how many context attachments (docs/issues) could not be fetched, which is why nothing was created (count is always >= 1). Provide ALL plural forms your language needs (English has 2; Polish/Ukrainian need 3 - one/few/many - via the custom pluralRules in i18n.config.ts)."
       }
     },
     "status": {

package/i18n/locales/es.json

@@ -311,7 +311,8 @@
         "derivedTitleFallback": "Revisar la pull request",
         "prNotFound": "No se encontró la pull request n.º {number} en el repositorio de este servicio. Comprueba el número, o vincula el servicio al repositorio en el que está esa pull request.",
         "prRepoMismatch": "Esa pull request está en otro repositorio. Este servicio revisa {repo}, así que crea la tarea de revisión en el servicio vinculado al repositorio de la pull request."
-      }
+      },
+      "contextFailed": "Tarea no creada: no se pudo leer {count} adjunto | Tarea no creada: no se pudieron leer {count} adjuntos"
     },
     "recurring": {
       "title": "Añadir una pipeline recurrente",
@@ -497,7 +498,8 @@
     "attachDocDisabledEnable": "Activa primero la integración de documentos",
     "attachIssueDisabledConnect": "Conecta primero un gestor de incidencias (Integraciones)",
     "attachIssueDisabledEnable": "Activa primero la integración del gestor de incidencias",
-    "importsOnAdd": "se importa al añadir"
+    "importsOnAdd": "se importa al añadir",
+    "unreadable": "No se pudo obtener: {error}"
   },
   "errors": {
     "generic": {
@@ -4166,7 +4168,15 @@
       "attachByReference": "Adjuntar {ref} por referencia",
       "noMatches": "No hay páginas que coincidan.",
       "emptySearchable": "Busca por título o elige un documento importado.",
-      "emptyRefOnly": "Pega la URL o el ID de una página para adjuntarla."
+      "emptyRefOnly": "Pega la URL o el ID de una página para adjuntarla.",
+      "refChecking": "Comprobando la referencia…",
+      "refUnrecognized": "No es una referencia de {source}. Se esperaba {expected}",
+      "refOtherSource": "Es un enlace de {claimed}, no de {source}.",
+      "refSwitchSource": "Usar {source} en su lugar",
+      "refTrimmed": "Recortado al formato admitido",
+      "refWidened": "Nombra un marco que esta fuente no puede leer ({scope}), así que se adjunta el archivo completo.",
+      "refAlreadyAttached": "Esta referencia ya está adjunta.",
+      "refCheckFailed": "No se pudo comprobar la referencia: {error}"
     },
     "repoPicker": {
       "searchRepoPlaceholder": "Buscar repositorios…",
@@ -6296,7 +6306,8 @@
       "failedTitle": "No se pudo crear la iniciativa",
       "contextDocsHint": "Adjunta un requisito, RFC o PRD para que los agentes de planificación lo lean al delimitar y redactar el plan.",
       "contextIssuesHint": "Adjunta una incidencia para que los agentes de planificación vean su descripción y comentarios al redactar el plan.",
-      "linkFailed": "Iniciativa creada, pero no se pudo vincular {count} adjunto | Iniciativa creada, pero no se pudieron vincular {count} adjuntos"
+      "linkFailed": "Iniciativa creada, pero no se pudo vincular {count} adjunto | Iniciativa creada, pero no se pudieron vincular {count} adjuntos",
+      "contextFailed": "Iniciativa no creada: no se pudo leer {count} adjunto | Iniciativa no creada: no se pudieron leer {count} adjuntos"
     },
     "status": {
       "planning": "Planificando",

package/i18n/locales/fr.json

@@ -311,7 +311,8 @@
         "derivedTitleFallback": "Examiner la pull request",
         "prNotFound": "La pull request n° {number} est introuvable dans le dépôt de ce service. Vérifiez le numéro, ou reliez le service au dépôt qui héberge cette pull request.",
         "prRepoMismatch": "Cette pull request se trouve dans un autre dépôt. Ce service examine {repo} : créez la tâche de revue sous le service relié au dépôt de la pull request."
-      }
+      },
+      "contextFailed": "Tâche non créée : {count} pièce jointe illisible | Tâche non créée : {count} pièces jointes illisibles"
     },
     "recurring": {
       "title": "Ajouter une pipeline récurrente",
@@ -497,7 +498,8 @@
     "attachDocDisabledEnable": "Activez d’abord l’intégration de documents",
     "attachIssueDisabledConnect": "Connectez d’abord un suivi de tickets (Intégrations)",
     "attachIssueDisabledEnable": "Activez d’abord l’intégration du suivi de tickets",
-    "importsOnAdd": "importé à l’ajout"
+    "importsOnAdd": "importé à l’ajout",
+    "unreadable": "Récupération impossible : {error}"
   },
   "errors": {
     "generic": {
@@ -4166,7 +4168,15 @@
       "attachByReference": "Joindre {ref} par référence",
       "noMatches": "Aucune page correspondante.",
       "emptySearchable": "Recherchez par titre ou choisissez un document importé.",
-      "emptyRefOnly": "Collez l'URL ou l'ID d'une page pour la joindre."
+      "emptyRefOnly": "Collez l'URL ou l'ID d'une page pour la joindre.",
+      "refChecking": "Vérification de la référence…",
+      "refUnrecognized": "Ce n'est pas une référence {source}. Format attendu : {expected}",
+      "refOtherSource": "C'est un lien {claimed}, pas un lien {source}.",
+      "refSwitchSource": "Utiliser {source} à la place",
+      "refTrimmed": "Réduit au format pris en charge",
+      "refWidened": "Désigne un cadre que cette source ne peut pas lire ({scope}) : le fichier entier est donc joint.",
+      "refAlreadyAttached": "Cette référence est déjà jointe.",
+      "refCheckFailed": "Impossible de vérifier la référence : {error}"
     },
     "repoPicker": {
       "searchRepoPlaceholder": "Rechercher des dépôts…",
@@ -6296,7 +6306,8 @@
       "failedTitle": "Impossible de creer l'initiative",
       "contextDocsHint": "Joignez une exigence, une RFC ou un PRD pour que les agents de planification la lisent en cadrant et en rédigeant le plan.",
       "contextIssuesHint": "Joignez un ticket pour que les agents de planification voient sa description et ses commentaires en rédigeant le plan.",
-      "linkFailed": "Initiative créée, mais {count} pièce jointe n’a pas pu être liée | Initiative créée, mais {count} pièces jointes n’ont pas pu être liées"
+      "linkFailed": "Initiative créée, mais {count} pièce jointe n’a pas pu être liée | Initiative créée, mais {count} pièces jointes n’ont pas pu être liées",
+      "contextFailed": "Initiative non créée : {count} pièce jointe illisible | Initiative non créée : {count} pièces jointes illisibles"
     },
     "status": {
       "planning": "Planification",