ai: requalify current model catalog, defaults and end-to-end AI functionality across all providers

[qnbs]

Origin / user request

WorldScript Studio's AI subsystem needs a comprehensive current-state requalification.

Two related problems need to be addressed together:

1. Model catalogues, defaults, fallbacks and provider-specific hard-coded model IDs have accumulated over time and are no longer guaranteed to represent the best currently available supported models.
2. The application's AI functionality has grown substantially, but the complete set of user-facing AI workflows has not yet been systematically exercised end-to-end against the real provider/runtime paths.

This issue owns a full AI model/provider refresh plus functional qualification of the complete AI product surface.

The goal is not merely to replace a few model strings. The goal is to establish:

CURRENT PROVIDER TRUTH
        ↓
CANONICAL MODEL/CAPABILITY AUTHORITY
        ↓
VETTED DEFAULTS
        ↓
CORRECT PROVIDER ADAPTERS
        ↓
REAL FUNCTIONAL QUALIFICATION
        ↓
MAINTAINABLE UPDATE / DEPRECATION POLICY

---

Why this is needed now

Current repository evidence already demonstrates model-authority drift.

Examples include:

• AiModel / settings contain comparatively recent Gemini/OpenAI/Anthropic/Grok model families;
• the canonical Gemini text fallback is still independently hard-coded in more than one runtime path;
• DefaultInferenceGateway.modelList() still exposes an older gemini-2.0-flash entry;
• OpenRouter has its own preferred-model/default/fallback authority;
• model choices appear in Settings/UI, storage normalization, inference routing, provider adapters, tests, documentation and help copy;
• local inference maintains additional independent WebLLM/ONNX/Transformers model catalogues.

This is concrete evidence that repository comments such as "current catalog" or "latest generation" cannot themselves be treated as current upstream truth.

All provider/model claims must therefore be re-derived from authoritative upstream sources at implementation time.

Do not assume that model names presently labelled "current" in source code are actually current.

---

1. Live upstream provider inventory

Before changing code, perform a live current-state investigation of every supported AI backend.

WorldScript currently models these provider classes:

gemini
openai
anthropic
grok
ollama
openrouter
webllm
onnx
transformers

Also account for local OpenAI-compatible runtime presets where applicable, including:

Ollama
LM Studio
vLLM
custom OpenAI-compatible endpoint

For each externally managed provider, inspect the official provider documentation/API at execution time.

Record at minimum:

Field	Required
exact model ID	yes
human display name	yes
availability state	stable / preview / experimental / deprecated / shutdown
text generation	yes/no
streaming	yes/no
structured/JSON output	yes/no
image input	yes/no
image generation	yes/no
tool/function calling	yes/no where relevant
reasoning support	yes/no/variant
context limit	where authoritative
output-token limit	where relevant
provider-specific parameter restrictions	yes
API/SDK compatibility	yes
pricing/free-tier status	when surfaced in WorldScript UX
deprecation/shutdown date	where published
recommended replacement	where published

Prefer official documentation, model-list APIs and official deprecation notices over blog posts, third-party model lists or repository comments.

For OpenRouter, verify current OpenRouter metadata rather than assuming a historical :free model remains free or available.

---

2. Separate "newest" from "best default"

Do not mechanically make every newest preview/experimental model the application default.

Establish explicit model lifecycle categories such as:

RECOMMENDED_DEFAULT
CURRENT_SUPPORTED
SPECIALIZED
PREVIEW_OPT_IN
LEGACY_COMPAT
DEPRECATED
REMOVED_UPSTREAM
UNKNOWN_STORED_VALUE

Selection of the WorldScript default should consider:

quality
stability
latency
availability
cost
rate limits
context window
structured-output reliability
streaming support
provider compatibility
creative-writing quality

A newer experimental model may be listed as an opt-in choice without replacing a proven stable production default.

Conversely, a deprecated/shutdown model must not remain an active default merely because it still exists in persisted types.

---

3. Inventory every model authority in the repository

Perform a repository-wide model-string and provider-authority audit.

At minimum inspect:

• types.ts / AiModel / AIProvider;
• features/settings/settingsSlice.ts;
• components/settings/AiSections.tsx;
• components/settings/OpenRouterSection.tsx;
• services/geminiService.ts;
• services/aiProviderService.ts;
• services/ai/providerFactory.ts;
• services/ai/inferenceGateway.ts;
• services/ai/worldScriptCompletionFetch.ts;
• services/ai/aiModeService.ts;
• services/ai/aiConstants.ts;
• hybrid fallback/routing;
• provider connection testing;
• IDB/settings normalization;
• filesystem/cloud settings persistence;
• per-project AI overrides;
• ProForge AI configuration;
• local AI model registries;
• WebLLM supported models;
• ONNX supported models;
• Transformers.js model assumptions;
• image-generation model IDs;
• documentation/help/locales;
• tests and fixtures;
• historical compatibility paths.

Search for all literal model IDs, not only known defaults.

Classify each occurrence as:

CANONICAL_AUTHORITY
DERIVED_VIEW
PERSISTED_LEGACY_COMPAT
TEST_FIXTURE
DOCUMENTATION
STALE_DUPLICATE_AUTHORITY
REMOVE

A model ID should not silently acquire multiple independent "default" authorities.

---

4. Establish a canonical model registry

Where practical, replace scattered current-model knowledge with one explicit capability-aware authority.

A model entry should be able to represent properties conceptually equivalent to:

provider
modelId
displayName
lifecycle
capabilities
stability
recommendedRoles
requiresApiKey
localOrCloud
supportsStreaming
supportsStructuredOutput
supportsImageInput
supportsImageGeneration
supportsReasoning
contextLimit
outputLimit
deprecation
replacementModel

Do not over-engineer this into a remote model-management platform.

The immediate objective is one auditable source from which Settings model choices, runtime validation, provider defaults, capability filters, model labels and fallback selection can derive consistently.

Provider APIs may still supply dynamic availability information, but WorldScript should retain an explicit curated admission layer rather than automatically trusting every remotely advertised model.

---

5. Remove stale duplicated defaults

After establishing authority, reconcile every fallback/default.

Patterns such as:

model?.startsWith('gemini-') ? model : '<hard-coded-model>'

must not independently drift from Settings, AiModel, inference gateways or model selectors.

The same applies to OpenAI defaults, Claude defaults, Grok defaults, OpenRouter fallback models, image-generation defaults, per-project preset defaults and local inference defaults.

Prefer shared provider-specific recommended defaults sourced from the canonical catalogue.

---

6. Capability-aware routing

Do not assume that every model from the same provider supports every WorldScript operation.

Build or verify capability admission for operations including:

TEXT
STREAMING_TEXT
STRUCTURED_JSON
IMAGE_INPUT
IMAGE_GENERATION
REASONING
TOOLS / FUNCTION CALLING
EMBEDDINGS / RAG

Only include capabilities WorldScript actually uses.

If a feature requires structured output, do not route it to a model merely because that model can generate ordinary prose.

If image generation is Gemini-specific today, make that truth explicit instead of giving other provider selections the appearance that image generation will work universally.

---

7. Provider adapter requalification

Exercise each currently supported provider adapter against current APIs/SDKs.

Gemini

Verify current text model, current image-generation model, structured JSON, streaming where used, current SDK semantics, reasoning/thinking configuration where applicable and deprecation removal.

OpenAI

Verify current supported model IDs, reasoning model compatibility, parameter differences between model families, streaming, structured output and custom/OpenAI-compatible endpoint behavior.

Do not assume every new OpenAI model accepts exactly the same temperature/token/reasoning parameters.

Anthropic

Verify current native Claude support, exact model IDs, request structure, output extraction, cancellation, token limits and provider-specific options.

xAI / Grok

Verify current exact IDs and OpenAI-compatible/native behavior actually used by WorldScript.

OpenRouter

Verify current endpoint contract, model IDs, free/paid state, account-credit UX, fallback behavior, routing/error metadata and rate-limit handling.

A historical :free identifier must not be presented as guaranteed free without current evidence.

Local/OpenAI-compatible

Verify Ollama, LM Studio, vLLM and custom endpoints separately where WorldScript claims support.

Do not equate "OpenAI-compatible" with complete behavioral parity automatically.

---

8. Local browser AI model requalification

Audit:

WebLLM
ONNX Runtime Web
Transformers.js

For each bundled/advertised local model determine whether the model still exists, the artifact still downloads, the current library supports it, memory footprint, browser compatibility, WebGPU/WASM requirements, approximate download size, practical minimum memory, context limits, and whether it actually performs the intended writing task acceptably.

Remove or clearly classify models that are technically loadable but no longer useful as realistic user-facing defaults.

Do not replace lightweight local defaults with models that make the application unusable on ordinary hardware solely because they are newer.

---

9. Persisted-model migration and compatibility

Existing installations may contain historical model IDs.

Do not blindly rewrite valid user preferences.

Classify persisted states:

CURRENT_SUPPORTED
DEPRECATED_BUT_AVAILABLE
REMOVED_UPSTREAM
UNKNOWN
MALFORMED

Required behavior:

• current supported explicit selection → preserve;
• deprecated but still usable → preserve or warn according to policy;
• removed/shutdown → offer/use a defined safe replacement;
• unknown future/custom model → preserve where the provider supports arbitrary IDs rather than destructively normalizing it away;
• invalid combinations → fail with actionable UX rather than silently routing to an unrelated provider.

Document all automatic migration rules.

---

10. Full inventory of AI product features

The second half of this issue is equally important:

Every actual AI feature exposed by WorldScript must be exercised and qualified.

First generate an authoritative inventory from all generateText, generateJson, generateImage, streaming/inference-gateway and equivalent call sites.

Known examples already include:

• Writer/completion workflows;
• manuscript continuation/generation;
• synopsis generation;
• character generation and field regeneration;
• world generation and field regeneration;
• Critic analysis;
• Consistency Checker;
• outline/story planning flows;
• scene-related generation;
• character interviews where AI-backed;
• scene visualization;
• character portraits;
• world images;
• ProForge pipeline agents;
• AI API/internal orchestration;
• plugin ai.invoke capability where enabled;
• model/provider connection tests;
• RAG/local-routing flows;
• per-project AI presets;
• hybrid fallback paths.

Do not assume this list is complete. Derive the final inventory directly from the current repository.

---

11. Build an AI feature × provider × capability matrix

Produce a matrix such as:

Feature	Text	JSON	Image	Streaming	Gemini	OpenAI	Claude	Grok	OpenRouter	Local
Continue writing	✓			✓
Critic	✓
Consistency	✓	structured/parsing
Character generation		✓/text
Character portrait			✓
…

Every cell must be classified as one of:

SUPPORTED_AND_QUALIFIED
SUPPORTED_NOT_YET_QUALIFIED
UNSUPPORTED_BY_PROVIDER
BLOCKED_BY_POLICY
LOCAL_ONLY
CLOUD_ONLY
NOT_APPLICABLE

Avoid pretending that every provider supports every feature.

---

12. Real functional smoke qualification

Unit mocks are necessary but insufficient for this work.

Establish a manual/opt-in real-provider qualification suite that can exercise actual APIs without putting provider secrets into the normal repository or mandatory public CI.

Do not add production API keys to GitHub.

For each supported provider with available maintainer credentials, verify representative real requests.

At minimum test:

Text

• simple generation;
• long-form writing continuation;
• cancellation;
• streaming where supported;
• non-empty result;
• Unicode/non-English text.

Structured output

• valid expected schema;
• malformed-model-output recovery;
• parser behavior;
• retry/fallback behavior.

Images

Where supported:

• character portrait;
• world image;
• scene visualization;
• valid returned artifact;
• error/cancellation path.

Local inference

• model initialization/download;
• successful inference;
• offline behavior after model availability;
• unsupported browser/runtime behavior;
• cancellation;
• memory/resource cleanup.

---

13. Test quality without brittle LLM assertions

Do not write tests expecting exact creative prose from live models.

Live qualification should assert stable properties such as request accepted, response non-empty, schema valid, language broadly correct, required keys present, image payload valid, no provider error, cancellation works and latency bounded enough for smoke qualification.

Mocked deterministic CI contract tests should cover exact adapter behavior separately.

---

14. Connection-test correctness

Audit every "Test connection" UI.

A green connection test must prove the configured provider/model can actually perform the minimum operation WorldScript will ask from it.

Do not report success merely because an API endpoint responds, a key has valid syntax or a provider account exists.

Differentiate errors such as:

NO_API_KEY
INVALID_KEY
MODEL_NOT_FOUND
MODEL_DEPRECATED
MODEL_ACCESS_DENIED
INSUFFICIENT_CREDITS
RATE_LIMITED
NETWORK_UNAVAILABLE
LOCAL_BACKEND_OFFLINE
CAPABILITY_UNSUPPORTED
PROVIDER_ERROR

Expose actionable UI without leaking sensitive provider responses.

---

15. Fallback-chain qualification

Audit hybrid fallback semantics.

Verify primary provider first, configured order respected, no duplicate provider attempts, unsupported capabilities skipped intentionally, auth failure does not create dangerous/unexpected cross-provider behavior, rate limits/transient errors follow defined policy, local-only/privacy modes cannot silently fall back to cloud and cloud fallback never bypasses explicit user privacy policy.

A fallback must not silently change from an image-capable model to a text-only provider and then surface an opaque failure.

---

16. AI mode qualification

Exercise all modes:

HYBRID
CLOUD
LOCAL
ECO

For each mode verify routing authority, model selection, settings UI, cold-start restoration, provider fallback, privacy policy, local/cloud boundaries and error messaging.

No mode should exist only as UI/state while behaving identically to another mode in runtime unless explicitly documented.

---

17. BYOK / secret safety

Preserve current provider-key security architecture.

During this work:

• never commit API keys;
• never include keys in logs;
• never persist provider keys in general Redux/project serialization;
• retain dedicated encrypted key-store authority;
• never expose secrets to plugins;
• redact provider errors where they may contain account/request metadata;
• do not weaken CSP/storage/privacy policy merely to support a provider.

Real qualification credentials must remain external to the repository.

---

18. Prompt / model compatibility

Model upgrades can change behavior even when the transport works.

Run representative prompt qualification for major WorldScript use cases.

Inspect system/user role assumptions, JSON-format instructions, prompt length, thinking/reasoning controls, stop sequences, temperature/top-p support, max-token semantics, multilingual prompts and creative-writing behavior.

Do not automatically carry provider-specific parameters to a model family that rejects or ignores them.

---

19. Defaults by workload, not one global model everywhere

Evaluate whether one default model is appropriate for all operations.

Potential roles include:

GENERAL_WRITING_DEFAULT
FAST_LOW_COST_DEFAULT
HIGH_QUALITY_REASONING
STRUCTURED_OUTPUT
IMAGE_GENERATION
LOCAL_LIGHTWEIGHT
OPENROUTER_FREE

If different workloads legitimately need different models, make that mapping explicit rather than scattering hidden exceptions.

Do not add complexity unless qualification evidence justifies it.

---

20. UI model catalogue correctness

Settings must show truthful current model information.

Verify provider grouping, display names, default selection, stable vs preview badges where useful, local/cloud indicator, free vs paid claims, unavailable/deprecated state, selected legacy value, capability mismatch and model access errors.

A removed model should not remain presented as a normal recommended choice.

---

21. Documentation and localization

After implementation, reconcile README, Help, AI/provider documentation, settings copy, provider counts, examples, model names, screenshots if model names are visible and all locale bundles through the normal i18n pipeline.

There is already evidence that provider-count/model-copy can drift between locales. Treat generated locale bundles according to repository authority rather than manually editing derived output.

Avoid prose such as "latest model" unless there is a maintainable definition or source.

---

22. Prevent the catalogue becoming stale again

Establish a bounded maintenance policy.

Prefer:

official upstream verification
        ↓
curated registry update
        ↓
focused provider contract tests
        ↓
real qualification
        ↓
release

Consider a scheduled/advisory model-health check for providers exposing stable machine-readable model metadata.

It must not automatically rewrite production defaults, make external provider availability a flaky mandatory PR gate, or automatically trust every remotely advertised model.

It may detect deleted/deprecated configured model IDs where reliably possible and produce actionable maintenance evidence.

---

23. Deprecation policy

Define what happens when a provider announces model retirement.

Suggested lifecycle:

CURRENT
  ↓
DEPRECATION ANNOUNCED
  ↓
REPLACEMENT QUALIFIED
  ↓
DEFAULT MOVED
  ↓
LEGACY SELECTION WARNED
  ↓
UPSTREAM SHUTDOWN
  ↓
REMOVED FROM NORMAL PICKER

Persisted projects/settings must not become impossible to load because an AI model disappeared.

Model selection is configuration, not project-data validity.

---

24. Performance / cost qualification

For recommended cloud defaults capture representative latency, output quality, token usage, context capability, rate limits and approximate cost class.

This does not require a full AI benchmark laboratory. It does require enough evidence to avoid selecting a dramatically slower or substantially more expensive default merely because it is newer.

For local models capture download size, startup/load time, RAM/VRAM requirements, representative generation speed and browser/runtime support.

---

25. Privacy-safe qualification evidence

Record a reusable AI qualification report without storing user manuscripts or secret prompts.

For each run record only what is necessary, for example:

provider
model
feature
result
capability
duration
error category
environment
date
application SHA

Do not log API keys, manuscript prose, private prompts/results, account identifiers, provider tokens or private filesystem paths.

Synthetic qualification fixtures should be used where possible.

---

26. CI versus real-provider testing

Maintain a clear separation.

Mandatory CI

Use deterministic mocks/fakes/contract fixtures for request construction, response parsing, model routing, fallback behavior, capability admission, persistence, cancellation and error classification.

Real provider qualification

Use controlled manual/opt-in runs for actual API availability, current model ID validity, provider behavior, real streaming, real structured output and real image generation.

Do not make ordinary PR CI depend on billable external AI APIs.

---

27. Architecture boundary

This issue should improve the current React/PWA/Tauri AI product without creating Tauri-only AI architecture.

Keep reusable semantics renderer-neutral where practical:

provider identity
model identity
capabilities
routing
policy
request/response contracts

The future Qt client should be able to consume the same provider/model authority through the intended shared boundaries rather than reimplementing another catalogue.

Do not start Qt implementation from this issue.

---

28. Implementation slicing

This issue is broad enough that implementation will likely require multiple causal PRs.

Prefer slices such as:

A. live inventory + canonical model authority
B. provider/default/catalogue reconciliation
C. cloud provider contract corrections
D. local model requalification
E. application-wide AI functional qualification
F. docs/UX/maintenance policy

Re-derive the exact split after inspection.

Do not submit one huge mixed PR if the work naturally separates.

Each PR must remain individually reviewable and reversible.

---

Acceptance criteria

• All nine declared AI providers are inventoried and classified against current implementation reality.
• Current upstream model availability is re-fetched from authoritative provider sources at implementation time.
• Every literal production model ID has a documented authority/classification.
• No deprecated/shutdown model remains an accidental active default.
• Recommended defaults are current, supported and qualification-backed.
• "Newest" and "recommended default" are explicitly distinguished.
• Model lifecycle states are represented explicitly.
• Settings, runtime routing, fallback logic and model lists derive from consistent authority.
• inferenceGateway, provider adapters and UI no longer expose contradictory current/default catalogues.
• Stored historical model selections have defined preserve/migrate/failure semantics.
• OpenRouter free/paid claims are verified against current truth.
• Local WebLLM/ONNX/Transformers models are requalified for availability and practical usability.
• Ollama/LM Studio/vLLM/custom local endpoints are exercised according to claimed support.
• Every user-visible AI feature has been inventoried.
• A feature × provider × capability support matrix exists.
• Representative text generation works against real qualified providers.
• Structured-output paths are qualified.
• Streaming paths are qualified where supported.
• Character/world/scene image-generation paths are qualified against the actual image model.
• Critic and Consistency Checker are functionally qualified.
• Writer/manuscript generation workflows are functionally qualified.
• Character/world generation workflows are functionally qualified.
• ProForge/provider-agent paths are reconciled where currently supported.
• AI connection-test UX proves meaningful provider/model usability.
• Cancellation, rate-limit, unavailable-model and auth-error paths are tested.
• Hybrid/cloud/local/eco routing is verified.
• Local-only/privacy policy cannot silently fall back to cloud.
• No real credentials are committed or exposed in logs.
• Real-provider smoke qualification is separated from deterministic mandatory CI.
• AI documentation/settings/help copy matches actual current behavior.
• A bounded ongoing model/deprecation maintenance policy prevents the catalogue from becoming silently obsolete again.
• All implementation PRs pass normal exact-head CI/CodeQL/review convergence and resulting-main verification.

---

Non-goals

• automatically adopting every new preview/experimental model;
• claiming the newest model is necessarily the best WorldScript default;
• putting paid external AI calls into mandatory PR CI;
• committing maintainer/provider credentials;
• deleting old persisted model values without compatibility handling;
• automatically trusting arbitrary models returned by a remote catalogue;
• rewriting the entire AI architecture unnecessarily;
• making every provider support every AI feature artificially;
• weakening privacy/local-only policy for fallback convenience;
• starting Qt implementation;
• benchmarking every model on the market;
• turning WorldScript into a generic provider/model marketplace.

---

Priority / disposition

P1

AI is a primary advertised WorldScript capability. The repository already contains demonstrable model-authority drift, and the complete AI surface has not yet received systematic real-provider functional qualification.

This is therefore more than routine model-version housekeeping: stale or retired model IDs, unsupported parameter combinations or unqualified provider paths can make core advertised functionality fail at runtime despite ordinary mocked CI remaining green.

[qnbs]

Canonical addendum merged from duplicate #703

The duplicate #703 contained several useful requirements that were either only implicit or less explicit in #704. These are now part of #704's acceptance contract as well.

Additional provider/model inventory requirements

For every provider/model inventory row, also record where authoritative and relevant:

• evidence date + official source;
• current role in WorldScript;
• upstream lifecycle state;
• capability set;
• context window;
• cost class;
• whether it is the current default/recommended choice;
• required action.

Where a provider exposes a live model-list endpoint, explicitly decide whether WorldScript should use dynamic enumeration, safely cached discovery, or a curated static subset. Do not adopt dynamic enumeration automatically: account entitlement, region restrictions, preview state, pricing and capability differences must remain explicit.

Additional local-runtime requirements

For Ollama, verify current discovery/list semantics and preserve support for arbitrary locally installed models without turning a recommendation list into a hard global allow-list. Do not silently download a model unless the existing UX explicitly authorizes it.

For WebLLM, qualify the model list against the exact admitted @mlc-ai/web-llm version and include quantization variant, download size, context window, WebGPU requirements, practical RAM/VRAM class, low-end hardware suitability and stale-checkpoint detection.

For ONNX Runtime Web, verify that every advertised model is still fetchable and compatible with the current runtime/export format.

For Transformers.js, do not equate a syntactically valid Hugging Face/Xenova identifier with proven runtime compatibility.

Expand the user-visible AI feature inventory

The inventory must explicitly search for and classify, where present:

• continue-writing;
• rewrite / expand / shorten / transform actions;
• brainstorming;
• outline generation;
• AI-backed template/personalization flows;
• character generation and interviews;
• world-building generation;
• critic/review;
• consistency checking;
• summaries/analysis;
• scene/plot assistance;
• RAG/context retrieval;
• embeddings/reranking if active;
• image/multimodal functions;
• local-AI workflows;
• hybrid fallback;
• command-palette/Copilot/assistant surfaces;
• background or batch AI tasks.

In addition to the feature × provider × capability matrix already required by #704, maintain a product acceptance view containing at least:

Feature | Entry point | Provider path | Input/context | Output mutation | Streaming | Cancellation | Error UX | Tested

This makes mutation authority and actual user entry points reviewable rather than testing only adapters in isolation.

Deterministic mutation-safety contract

Mocked/deterministic CI coverage must also prove that AI results are applied only to the intended current project/scene/document authority. Stale, cancelled, failed or cross-project results must not partially mutate or corrupt manuscript/project state.

Required representative end-to-end scenarios

The opt-in/manual qualification program must include representative scenarios equivalent to:

1. Generate a short continuation from manuscript context.
2. Brainstorm several story ideas.
3. Generate or modify an outline.
4. Create or enrich a character/world entity.
5. Run critic/review analysis on supplied text.
6. Run an AI-backed consistency check.
7. Cancel a streaming generation midway.
8. Exercise 401/403 authentication/access failure.
9. Exercise 429/rate limiting.
10. Exercise model unavailable/deprecated/removed behavior.
11. Exercise a network interruption mid-stream.
12. Exercise the intended hybrid cloud/local fallback path.
13. Prove Local mode performs no cloud request.
14. Change provider/model in Settings and prove the next real operation actually uses it.
15. Reload/relaunch and prove provider/model selection persists correctly.
16. Prove failed/cancelled generation never corrupts or partially applies manuscript/project mutations.

Use synthetic/non-sensitive content for qualification.

Qualification evidence record

For real-provider smoke runs, capture a privacy-safe record containing at least:

provider, model, UTC date, app SHA, feature/scenario, result, latency, streaming status, and error class where applicable.

Do not include secrets, full user prompts or manuscript text in logs/artifacts.

Additional capability/error classes to verify

Where used by the application, explicitly distinguish:

• VISION_INPUT;
• IMAGE_GENERATION;
• EMBEDDINGS;
• RERANKING;
• LONG_CONTEXT;
• LOCAL_EXECUTION.

Error qualification should additionally cover:

• context too large;
• provider outage;
• local model unavailable/not downloaded;
• WebGPU unsupported;
• local model OOM/load failure.

Browser/runtime truth and security

Documentation/Settings truth must include browser-vs-desktop/runtime restrictions where relevant.

Do not introduce a generic/open proxy merely to make Anthropic or another browser-constrained provider callable. Preserve the existing provider/privacy architecture.

All provider/model output that can cause project mutations must continue through existing validation/mutation authority; a catalogue refresh must not create a bypass.

These requirements are merged from #703 and are canonical under #704. #703 can therefore be closed as duplicate.

[qnbs]

Execution disposition — prioritize as dedicated P1 workstream

Maintainer decision (2026-09-10): after the current CHANGELOG-admission prevention work (#705) is fully terminal — including resulting-main CI/CD + CodeQL — pause the previously approved normal remediation sequence and promote #704 into the next dedicated independent workstream.

Required execution model:

1. Planning only first. Start a fresh Claude Code CLI Plan Mode pass from the then-current green main; do not implement while planning.
2. Re-fetch current upstream provider/model truth at planning time. Do not treat model IDs embedded in this issue, repository comments, prior audits, or model memory as current authority.
3. Produce a complete evidence-backed implementation plan covering the entire ai: requalify current model catalog, defaults and end-to-end AI functionality across all providers #704 contract, issue boundaries, provider/model authority, migration/preserve-first behavior, functional qualification, real-provider smoke strategy, local-runtime qualification, security/privacy and PR slicing.
4. Stop after the plan and bring the complete plan back to ChatGPT for independent review, live repo reconciliation, critique, gap analysis, sequencing improvement and anti-cascade refinement.
5. Only after that plan review/refinement, execute ai: requalify current model catalog, defaults and end-to-end AI functionality across all providers #704 through Claude Code CLI in bounded causal PRs, with normal focused validation, ci:prepush, exact-head CI/CD + CodeQL + review convergence, merge, and resulting-main verification for each slice.
6. Complete ai: requalify current model catalog, defaults and end-to-end AI functionality across all providers #704's accepted terminal criteria before resuming the previously planned ordinary remediation sequence, unless a genuinely higher-severity emergency or security/data-integrity blocker appears.

This prioritization must not cause #704 to become one giant implementation PR. It remains an umbrella P1 workstream whose implementation should be split into the smallest coherent, reviewable, reversible slices derived from evidence.

No unrelated architecture expansion, Qt implementation, provider-secret handling, paid API calls in mandatory CI, privacy-policy weakening, or forced migration of explicit user model/provider preferences.

[qnbs]

Execution truth sync — Wave 0A merged via #706

PR #706 has merged as the first bounded implementation slice of this workstream.

Merged PR: #706 — fix(ai): close cloud-AI policy bypass in generateJson/generateImage/streamAiHelpResponse

• final PR head: a2c249f07296c612f2f46acdae8424fd449b1b53
• resulting main: 3b3c8c4088963f360b4cb1dbc26b1f2243611872
• merge time: 2026-09-11 12:51:56 UTC
• resulting-main signature verification is green; resulting-main CI/CD + CodeQL are still running at the time of this comment, so Wave 0A is merged but not yet terminal until both complete successfully.

Wave 0A scope now implemented

#706 closed the two P0 policy/routing findings assigned to Wave 0A and the causal regressions exposed during review convergence:

• Gemini-direct generateJson, streamAiHelpResponse, and generateImage now enforce the actual cloud-AI policy before cloud execution.
• unsupported image providers no longer silently fall through to Gemini.
• thunk policy pre-checks now use the effective preset/routing-aware provider instead of the global provider setting.
• text/stream positive routing is shared without importing the full provider graph into thunk code.
• OpenRouter promotion/fallback semantics were reconciled for streaming, including model selection, duplicate-attempt prevention, cancellation propagation, and fallback-reason bookkeeping.
• the newly reachable local streaming path now forwards cancellation correctly.

These fixes remain part of #704's qualification evidence; do not reopen them in later waves unless fresh evidence shows a regression.

Residual disposition from #706 review — keep under #704, do not create a duplicate issue

Review exposed a narrower capability/routing semantic mismatch around image thunks:

peekPositiveRoutingProvider() is currently a text-oriented positive-routing predictor and can resolve a nominal cloud provider to a local/OpenRouter text provider, while generateImage() presently implements only the explicit Gemini image-generation path (other providers fail explicitly).

This was re-checked during #706 convergence and is not a cloud-privacy bypass: the actual Gemini image path performs assertCloudAiAllowed('gemini') immediately before provider/network work. The residual concern is that generic pre-check prediction and operation-specific capability execution can disagree about what provider is meaningful for IMAGE_GENERATION.

Canonical owner remains this issue's existing capability-aware routing + feature × provider × capability matrix work. During that later slice, make routing/pre-check semantics operation/capability-aware where required rather than treating text positive-routing as universally applicable. Do not imply that WebLLM/OpenRouter provides image generation unless that exact capability is implemented and qualified.

This residual is non-blocking for #706 and should not be split into a new issue unless later implementation proves it requires an independently owned subsystem.

Next execution slice after Wave 0A terminalization

Proceed with Wave 0B — cross-project late-result mutation safety only after resulting-main CI/CD + CodeQL for 3b3c8c4088963f360b4cb1dbc26b1f2243611872 are terminal green.

Required invariant for Wave 0B:

Every AI mutation flow must retain the originating project identity from dispatch/generation start and must refuse/drop a late result if the active/current project no longer matches that origin.

A generation/request token may supplement this protection, but must not substitute for explicit project identity. Keep Wave 0B separate from Wave 0C cancellation/lifecycle work.

No normal pre-#704 remediation work resumes until #704 is terminal unless a genuinely higher-severity emergency is discovered.

[qnbs]

Wave 0B post-merge truth sync — PR #707 is terminal, but Wave 0B still has validated mutation-authority residuals

Independent post-merge audit performed against current main after PR #707.

PR #707 terminal evidence

• PR fix(project): guard AI-generation results against a stale/switched active project #707 merged.
• Final PR head: c8a128ccf344c27c10526837d9d5902e8089c473
• Resulting main / merge commit: 8a65f1b3b8d207f9f009dde545d1b854148e9779
• Final PR size: 4 commits, 17 changed files, +592 / -61.
• Resulting-main CI/CD is green.
• Resulting-main CodeQL SAST is green.
• Merge commit is signature-verified.

#707 correctly closed the original core defects around project-incarnation identity: the same-id:'default' reset/import/restore problem is now distinguished with an in-memory generation counter; identity checks fail closed; Character/World profile + field regeneration, template personalization/custom generation, outline generation/apply, and snapshot-restore identity handling gained the intended authority checks/regressions.

Disposition: PR #707 itself is terminal and should not be reopened. Wave 0B is not yet terminal, because the required post-merge completeness sweep found real project-authority surfaces outside #707's final diff.

Validated residual A — P1: AI image writes are not project-authorized

Affected user flows:

• Character portrait generation
• Character portrait refinement
• World image generation
• World image refinement
• Manuscript scene visualization

generateCharacterPortraitThunk, generateWorldImageThunk, and generateSceneImageThunk await AI image generation and then call storageService.saveImage(...) without capturing/rechecking project incarnation.

The persistence boundary is also globally keyed rather than project-namespaced:

• IndexedDB image store writes store.put(payload, id);
• filesystem image store writes appData/images/<id>.png;
• by contrast, binder assets explicitly include projectId in their storage key/path.

Character/World fulfilled reducers additionally update the currently active project slice by entity ID. A late request from project A can therefore write an asset after project B is active and, where B carries the same entity/section IDs (e.g. imported/copied/restored project material), can overwrite or mark B's corresponding asset/state.

Required contract: stale AI image results must be rejected before any persistent asset commit and before any current-project reducer mutation. Do not rely only on a hook-level check after the thunk returns; that is already too late for saveImage.

Validated residual B — P1: Character Interview stream chunks can mutate the current project

streamInterviewResponseThunk resolves the Character/Interview from the starting state, but its later streaming callback dispatches updateCharacterInterview and project/streamInterviewChunk using only characterId/interviewId/aiMsgId. The reducers/matcher then resolve those IDs against the current project slice. There is no captured project incarnation in the stream authority.

This belongs to Wave 0B mutation authority. General AbortController / Stop Generation lifecycle redesign remains Wave 0C and must not be pulled in except where strictly necessary to stop stale mutation.

Validated residual C — P1: Writer AI results are project-unowned and can later be accepted into another project

Both Writer streaming paths (orchestration via useWorldScriptAI and legacy streamGenerationThunk) accumulate AI output in writerSlice without an originating project identity. handleAccept() later reads that history and writes it into the manuscript section resolved from the current project.

Therefore an A-originating generation can remain available after A → B and be inserted/replaced into B. Cancellation lifecycle remains Wave 0C; ownership/admission of the result is Wave 0B.

Validated residual D — P1: Global Copilot results are project-unowned at apply time

Global Copilot streams responses into copilotSlice without binding the response to the originating project incarnation. applyLastSuggestion() then applies a code block from the last assistant response to activeSectionId in the current project.

A response generated from project A context must not remain applicable to project B merely because the Copilot UI survives the project transition.

Validated residual E — P2 / bounded correctness: deferred/local AI results need owner identity too

The final #707 head still has the late CodeRabbit outside-diff finding in useOutlineGenerator.handleRegenerate: regenerated section preview state can be replaced after a project switch even though the later apply() guard prevents persistence.

The same ownership pattern exists in additional deferred/local AI outputs:

• Manuscript logline suggestions: A result can remain selectable and selectLogline() mutates the current project.
• Proofread suggestions: A suggestions can remain available and later be applied against the current section.
• Export synopsis: A-generated synopsis is local state and can be mixed into a B export after a project transition.
• Scene image preview should be invalidated together with its project authority even after the persistent write path is fixed.

These are lower severity than direct stale asset/state mutation, but they violate the same origin/authority contract and should be closed before declaring Wave 0B terminal.

Acceptance criteria for Wave 0B completion

1. Every AI result derived from project-owned context that can directly mutate state/assets or later be applied/exported carries an originating project-incarnation authority.
2. Direct Redux mutations reject stale authority before mutating the current project.
3. Persistent image/asset writes reject stale authority before commit; project switching must not permit a late A generation to overwrite B-owned assets.
4. Streaming callbacks (Interview, Writer/Copilot where relevant) cease admitting result mutations once authority changes. Do not conflate this with full Wave 0C cancellation semantics.
5. Deferred/local result containers (outline regeneration, logline, proofread, synopsis, Copilot/Writer result buffers where retained) are either owner-tagged and guarded at apply/export, or cleared deterministically on project-incarnation change.
6. Add focused regressions for reset/import/restore while work is in flight, including the same persisted id:'default' with a changed generation and a copied/imported project carrying identical entity IDs.
7. Keep identityUnchanged fail-closed semantics and the generation-counter contract introduced by fix(project): guard AI-generation results against a stale/switched active project #707.
8. No new duplicate issue: these findings remain canonical under ai: requalify current model catalog, defaults and end-to-end AI functionality across all providers #704.

Recommended bounded continuation

Do not advance to Wave 0C yet.

Prefer a fresh successor slice from current green main:

• Wave 0B.1: direct stale mutation/storage/stream admission — image thunks + image reducers/storage boundary, Character Interview stream authority, Writer/Copilot result ownership where it enables project mutation.
• Wave 0B.2: deferred/local result ownership — outline section regeneration, logline/proofread/synopsis/preview invalidation and apply/export guards.

Each slice should use a fresh PR/commit budget, focused regression tests, ci:prepush, exact-head review/CI/CodeQL convergence, merge, and resulting-main verification. Only after both residual groups are source-closed and resulting-main is green should #704 transition to Wave 0C.

[qnbs]

E2E / feature-flag qualification decomposition — execution map

A live post-#707 audit found that #704's functional-qualification obligation needs explicit test owners beyond the current product-source waves. To keep the work causal/reviewable and avoid one giant E2E PR, the following dedicated issues now own the test side:

#709 — feature-test coverage authority

test(feature-flags): establish exhaustive coverage authority and prevent opt-in E2E blind spots

Owns the structural/governance layer:

• exhaustive FeatureFlagsState → test-disposition registry;
• type-safe setFeatureFlags();
• prevention of ad-hoc flag-storage setup drift;
• test-coverage parity/admission;
• making criticalCombinations actually execute;
• truthful required/advisory/runtime-specific coverage classification.

This is the preferred foundation before adding a large volume of new feature E2Es.

#710 — functional AI product E2E

test(ai-e2e): qualify Copilot, Character Interviews, ProForge and mutation-capable AI user flows

Owns deterministic real-product journeys with external provider transport mocked only at the network/runtime boundary:

• Global Copilot send/render/apply;
• Character Interview streaming;
• bounded ProForge orchestration/HITL;
• Writer generation/accept;
• representative proofread/logline/synopsis/image flows after their source authority contracts are safe.

This is the browser/product evidence counterpart to #704's AI functional qualification. It must not duplicate source fixes owned by #708/Wave 0B or cancellation architecture owned by Wave 0C.

#711 — default-off Settings/opt-in admission

test(opt-in): qualify Settings admission, persistence and network/runtime safety for default-off features

Owns the actual supported opt-in path rather than only LocalStorage-seeded test setup:

• Settings toggle → Redux/persistence → reload → runtime gate;
• Global Copilot / ProForge opt-in persistence;
• Voice + Voice-WASM dependency admission;
• RTL ON/OFF direction contract;
• Browser-Ollama network-inert while OFF and explicit user-action network behavior while ON;
• Local-First Sync bounded shadow/persistence contract;
• explicit NOT_APPLICABLE/native disposition for Rust Compute while desktop-only/stub.

#712 — production-bundle functional canaries

test(prod-e2e): add risk-based functional canaries against the built production bundle

Owns the bounded gap between:

• broad Playwright E2E against vite dev; and
• current production smoke:prod that proves mount/CSP/WASM but not feature journeys.

It must stay intentionally small: selected high-risk lazy/opt-in/bundling-sensitive canaries against the exact built dist, not a second copy of the entire Playwright suite.

---

Existing owners that remain authoritative

• ai(project): bind asynchronous image and interview side effects to originating project #708 — current Wave 0B image/interview project-mutation + asset authority source fixes.
• ci: define e2e-deep advisory graduation and expiry evidence #623 — e2e-deep advisory graduation/expiry evidence. New issues must not make the whole deep lane blocking by fiat.
• ci(efficiency): reduce redundant cost and latency without weakening required quality/security gates #550 — CI cost/latency/artifact-reuse optimization after the required evidence contract is known.
• E2E WelcomePortal entry remains nondeterministic across startup states #532 — WelcomePortal/startup E2E nondeterminism; do not mask it with retries/timeouts while expanding tests.
• pwa(first-class): harden offline reliability, lifecycle, performance, install/update UX & browser-native AI #478/pwa(ai): turn WebGPU/worker local inference into a zero-install offline AI differentiator #483/pwa(capabilities): establish progressive-enhancement registry, browser support tiers & runtime diagnostics #489 — broader PWA/local-AI/browser-capability architecture.
• local-first: migrate manuscript text to Y.Text and gate the source-of-truth flip #555/Reset-gate follow-ups from #596: local-first Safari fallback, encryption-remanence clearData() propagation, IdbConnectionManager test-closer leak #602 — Local-First authority evolution and specific reset/remanence follow-ups.

---

Recommended dependency order

active #708 / remaining Wave 0B data-integrity source fixes
        ↓
#709 coverage authority
        ↓
#711 opt-in admission + #710 functional AI E2E
        ↓
#712 selected production-bundle canaries
        ↓
#623 evidence-based promotion/expiry decisions

#710/#711 can proceed in bounded parallel slices once the relevant production source contract is terminal; do not block unrelated stable feature tests on an unrelated #708 subpath.

The governing rule remains: source correctness first, then deterministic product evidence, then CI-lane graduation. Do not knowingly carry a validated mutation/data-integrity defect forward merely because an E2E can be written around it.

[qnbs]

Canonical execution-owner update — Wave 0B/Wave 0C decomposition

The post-#707 completeness audit has now been converted into durable child ownership so critical source work is no longer tracked only in this umbrella's comments/prompts.

Current AI correctness/lifecycle owner graph

#704 — canonical AI/model/provider umbrella
  │
  ├─ #708 — DIRECT / PERSISTENT / STREAMING PROJECT AUTHORITY
  │    Character portrait/refinement
  │    World image/refinement
  │    Scene image persistent-write path (scope addendum)
  │    image-storage ownership / same-ID collision analysis
  │    Character Interview stream mutation authority
  │
  ├─ #713 — DEFERRED / APPLY-LATER PROJECT AUTHORITY
  │    Writer result/history ownership
  │    Writer Accept insert/replace
  │    Global Copilot result/apply ownership
  │    outline regeneration preview
  │    logline suggestions
  │    proofread suggestions
  │    AI synopsis/export contamination
  │    stale Scene/other previews
  │    repository-wide deferred-result sweep
  │
  ├─ #714 — WAVE 0C REQUEST LIFECYCLE
  │    Stop Generation
  │    AbortSignal propagation
  │    cancellation
  │    supersession/latest-request semantics
  │    duplicate-request admission
  │    streaming late-event admission
  │    unmount/navigation cleanup
  │    timeout/fallback cancellation semantics
  │
  ├─ #709 — feature/test coverage authority
  ├─ #710 — deterministic functional AI E2E
  ├─ #711 — default-off Settings/admission/network-safety qualification
  └─ #712 — selected production-bundle functional canaries

Non-negotiable semantic separation

PROJECT INCARNATION AUTHORITY
#707 + #708 + #713
= MAY this result/chunk/write affect the active project now?

REQUEST LIFECYCLE
#714
= SHOULD the underlying work still run/admit events/retry/fallback?

FUNCTIONAL EVIDENCE
#709–#712
= DOES the admitted product contract work end-to-end under the intended CI/runtime layer?

Cancellation must never replace project-incarnation authority. A cancelled provider may still deliver a late callback; a non-cancelled request may become stale because the user switched/reset/imported/restored the project.

Sequencing update

For implementation ordering, treat the current preferred sequence as:

#708 + #713
complete Wave 0B source correctness / data-integrity authority
        ↓
#714
Wave 0C lifecycle convergence
        ↓
#709
coverage authority foundation where not already terminal
        ↓
#710 / #711
functional/admission qualification
        ↓
#712
small risk-based production-bundle canaries
        ↓
#623
advisory → required graduation only from evidence

Bounded parallel work is acceptable where dependencies do not overlap, but do not merge lifecycle/test layers ahead of unresolved source correctness merely because they were started first.

Scope conservation

This decomposition does not expand #704 into more architecture. It narrows execution ownership:

• provider/model truth, canonical model/capability registry, provider requalification, persisted model compatibility, real-provider qualification and maintenance/deprecation policy remain owned here;
• project mutation/result authority moves to ai(project): bind asynchronous image and interview side effects to originating project #708/ai(project): bind Writer, Copilot and deferred AI results to originating project incarnation #713;
• general cancellation/supersession lifecycle moves to ai(lifecycle): unify Stop Generation, cancellation, supersession and duplicate-request semantics #714;
• test-governance/product-evidence layers remain test(feature-flags): establish exhaustive coverage authority and prevent opt-in E2E blind spots #709–test(prod-e2e): add risk-based functional canaries against the built production bundle #712.

No duplicate issue should be created for these same scopes unless a later source audit proves a genuinely separate subsystem owner is required.

[qnbs]

2026-09-11 execution-focus refinement — start provider/model work with the smallest canonical authority slice

The current deep-audit and the #706/#707/#718 incident chain reinforce the existing #704 decomposition: this umbrella is correct, but implementation should not begin as one broad provider×feature matrix PR.

Admission before #704 provider/catalog mutation

Current source/data-integrity work remains the immediate frontier:

#708 + #713
project-incarnation authority
        ↓
#714
request lifecycle / cancellation / supersession
        ↓
#709 minimum coverage authority

Do not let model-catalogue work leapfrog unresolved source authority merely because #704 predates those child issues.

First bounded #704 implementation slice after that gate

Prefer a small, auditable canonical model/capability authority PR that does only the minimum needed to eliminate duplicated current-model truth:

1. live upstream re-fetch from official provider sources at execution time;
2. repository-wide literal model/default/fallback inventory;
3. one curated canonical registry/lifecycle representation;
4. derive Settings/runtime defaults and capability admission from that authority where safely possible;
5. remove/reclassify demonstrably dead/stale production model IDs and duplicated hard-coded defaults;
6. preserve valid explicit/custom persisted user selections according to the existing compatibility contract;
7. make each provider "Test connection" exercise the same minimum real operation/capability shape the product will use, rather than only proving endpoint/key reachability.

Do not bundle the full live-provider qualification matrix, all local-model benchmarking, all AI E2E, docs/locales and maintenance automation into that first PR.

Why this slice is high leverage

The recent #706 privacy-policy bypass showed the recurring failure mode:

multiple authorities
→ preflight reads one value
→ runtime uses another
→ fallback chooses a third
→ policy/test truth diverges

A singular admitted model/provider capability authority reduces that class before broader qualification begins.

Subsequent causal slices

After the registry/default slice is stable, continue through bounded owners:

provider adapter/default reconciliation
→ persisted legacy/custom compatibility
→ local-runtime requalification
→ #710/#711 deterministic product/admission evidence
→ controlled real-provider qualification
→ docs/UX/deprecation maintenance
→ #712 only for selected exact-production-bundle signals

Anti-cascade

• no automatic adoption of every newest/preview model;
• no remote catalogue as automatic production authority;
• no paid external API calls in mandatory PR CI;
• no forced rewrite of explicit custom model IDs;
• no Qt/native renderer work;
• no new model marketplace abstraction;
• no reopening project-authority/cancellation ownership already assigned to ai(project): bind asynchronous image and interview side effects to originating project #708/ai(project): bind Writer, Copilot and deferred AI results to originating project incarnation #713/ai(lifecycle): unify Stop Generation, cancellation, supersession and duplicate-request semantics #714.

The goal is to make #704 smaller to execute and stronger as authority, not to reduce its eventual qualification contract.

[qnbs]

2026-09-12 Claude API / ProForge prompt-audit — execution-owner graph

The /claude-api prompt-audit produced exactly three material findings (plus two deliberately non-ticketed low-confidence notes). All three now have durable execution owners and matching prep/evidence PRs:

#704  P1 — AI provider/model/functional qualification umbrella
│
├─ #729  P2 — native Claude structured outputs for schema-bound ProForge stages
│    ↕
│   #730 — prep/evidence: PROFORGE-CLAUDE-STRUCTURED-OUTPUTS-PLAN.md
│
├─ #731  P1 — Claude response budgets / timeout right-sizing + real end-to-end SSE streaming
│    ↕
│   #728 — prep/evidence: PROFORGE-CLAUDE-MAXTOKENS-CEILING-PLAN.md
│
└─ #732  P2 — replace character-count token metrics with provider usage telemetry
     ↕
    #727 — prep/evidence: PROFORGE-CLAUDE-TOKEN-ACCOUNTING-PLAN.md

Requalification notes

• feat(proforge): plan Claude structured-outputs wiring #730 corrected the original audit's broad stage inventory: six ProForge agents currently make JSON-producing AI calls; AnalyticsAgent makes no AI call and is not part of ai(proforge): use native Claude structured outputs for schema-bound pipeline stages #729's current migration scope.
• feat(proforge): plan Claude structured-outputs wiring #730 also proved that naïve Zod→JSON-Schema output is not acceptable for the current Anthropic structured-output subset; ai(proforge): use native Claude structured outputs for schema-bound pipeline stages #729 now owns the explicit sanitizer-vs-SDK design decision and provider-schema compatibility tests.
• docs(proforge): plan Claude max_tokens/timeout right-sizing #728's suggested 32K / 55s / 16K publishing values are candidates, not permanent constants. ai(claude): right-size ProForge response budgets and implement real end-to-end streaming #731 owns model/host/workload requalification plus the larger real-streaming architecture.
• docs(proforge): plan real token accounting for the Claude path #727's estimator swap is an interim correctness fix; ai(proforge): replace character-count token metrics with provider usage telemetry #732 keeps the larger provider-usage/result-contract work durable so an approximation cannot silently become the permanent token-accounting architecture.

Negative audit evidence / intentionally no issue

The audit explicitly found no additional material Claude-prompt/API cleanup class beyond those three findings:

• no Anthropic tool/function-calling definitions were present, so there is no tool-description/tool-schema modernization issue to create;
• CLAUDE.md / skill/instruction context had already been checked and did not contain the incident-ID/version-pin/dated-idiom problems the audit was looking for;
• the general prompt prose did not show a stale CRITICAL/MUST marker-density or obsolete choreography problem worth ticketing;
• no non-Anthropic code is being proposed for migration to the Anthropic SDK merely because Claude supports newer API features.

Deliberately NOT split into more issues

The audit's two secondary observations remain non-issues unless later evidence changes:

1. retry feedback (IMPORTANT — your previous attempt was rejected...) carries real per-attempt context and should remain;
2. the COHERENT: / INCOHERENT: self-reflection prefix is load-bearing because the caller exact-matches it; revisit only after ai(proforge): use native Claude structured outputs for schema-bound pipeline stages #729 if there is a concrete simplification.

Ordering

These tickets refine #704; they do not supersede the already-established data-integrity/authority sequence. Re-fetch live P0/P1 state before execution. In particular, do not use these prep PRs to leapfrog the remaining #708 project-incarnation authority work merely because the plans are ready.

The prep PRs are evidence/plans and should not auto-close their execution issues when merged.

[qnbs]

#704-A live requalification checkpoint (2026-09-13)

Current source confirms that services/ai/cloudModelCatalog.ts is the existing canonical cloud-catalog nucleus: Settings options, direct-provider fallbacks, persisted-settings normalization, and the Claude proxy allowlist already depend on it. No second cloud model authority will be introduced.

Bounded credential-free slice:

• requalify the curated Gemini, OpenAI, Anthropic, and xAI entries against official public model documentation;
• consolidate lifecycle/capability metadata, role-based defaults, provider options, and known persisted-value migrations in the existing catalog authority;
• reconcile duplicate cloud defaults in settings, service fallbacks, inference model listing, and ProForge defaults where they are the same catalog contract;
• preserve dynamic OpenRouter discovery as runtime discovery rather than exposing every upstream model; refresh only its curated offline fallback/default from the unauthenticated official /api/v1/models catalogue;
• add focused deterministic catalog, fallback, and persisted-admission coverage plus the required product-truth documentation.

Official public sources checked: Google Gemini models (https://ai.google.dev/gemini-api/docs/models), OpenAI models (https://platform.openai.com/docs/models), Anthropic models (https://docs.anthropic.com/en/docs/about-claude/models), xAI models (https://docs.x.ai/docs/models), and OpenRouter public models (https://openrouter.ai/api/v1/models).

Explicit qualification gap: authenticated account entitlement, real request acceptance, provider latency/quality, and live streaming/image/structured-output behavior remain CREDENTIAL_REQUIRED / NOT_YET_REAL_PROVIDER_QUALIFIED for the later opt-in #704 qualification wave. No provider credentials or paid/live inference calls are used in #704-A.

Out of scope: provider adapter rewrites, complete provider×feature E2E, local-model catalogue changes, recurring automation, and #729/#731/#732 implementation.

[qnbs]

#704-A execution checkpoint — first-push governance bootstrap gap (2026-09-13)

The credential-free catalogue implementation is complete locally as signed commit 21248d4a5bd0cf10304679ba34a720a5d510cfe2, based on resulting main fc10aaf8f4011f9759e8b0bdcc7cb390f74e530e.

Deterministic evidence is green: focused suite 180/180, typecheck, lint, documentation metrics, and diff hygiene. The canonical explicit-base prospective/committed budget is also green at 24 files / 950 meaningful lines / 1 commit, with 6 files and 14 commits of absolute reserve; the slice is intentionally frozen in convergence mode.

Push is currently blocked by the repository’s installed first-branch pre-push path: signing and attribution pass, but ci:prepush invokes pr-budget --prepush without an explicit-base input. Before an open PR exists, it fails closed with UNRESOLVED_BASE even though the authoritative main SHA is known and pnpm run pr:budget -- --base fc10aaf8f4011f9759e8b0bdcc7cb390f74e530e --head HEAD --prospective --no-live passes. The dry-run confirmed this exact state.

No --no-verify, fabricated event, API-created ref, unsigned commit, or governance bypass was used. This is a repository governance-bootstrap follow-up, not a provider-credential limitation and not a #704-A source defect. The signed local branch remains preserved for continuation once the canonical explicit-base pre-push path is available.

[qnbs]

#704-A execution checkpoint — PR opened (2026-09-13)\n\nCredential-free model-currency slice is open as PR #739: https://github.com/qnbs/WorldScript-Studio/pull/739\n\nBase: fc10aaf\nHead: 21248d4\nBudget: 24 changed files / 950 meaningful lines / 1 signed commit\n\nThe branch passed the canonical PR_BUDGET_BASE bootstrap and sequential pre-push admission. Public official provider documentation was used for the catalogue checkpoint; authenticated entitlement, real-provider inference, and provider smoke qualification remain CREDENTIAL_REQUIRED / NOT_YET_REAL_PROVIDER_QUALIFIED for a later opt-in #704 slice. No credentials or live inference calls were used.\n\nThe prior UNRESOLVED_BASE checkpoint is superseded: live source review confirmed that PR_BUDGET_BASE is the intended first-push mechanism. No governance-bootstrap PR is required. Current scope is frozen to #704-A; adapter rewrites, full feature-matrix E2E, local catalogue overhaul, recurring automation, and #713/#714 work remain out of scope.

[qnbs]

2026-09-13 #704-A re-baseline: the current official Google Gemini models page was rechecked during the PR #739 review wave. It lists upstream Gemini 3.8/3.7/3.6/3.5 Flash, 3.5 Flash-Lite, and 3.1 Flash-Lite families; gemini-3.1-flash was not present in the extracted current public list. PR #739 now records that distinction explicitly: the existing cloudModelCatalog.ts remains the canonical authority, the reviewed product subset is curated rather than exhaustive, gemini-3.1-flash is legacy compatibility, and gemini-3.1-pro-preview remains opt-in. The correction wave is credential-free; authenticated entitlement, live inference, quality/latency, streaming, structured-output, and image qualification remain CREDENTIAL_REQUIRED / NOT_YET_REAL_PROVIDER_QUALIFIED for a later opt-in slice. The prior first-push governance-bootstrap concern remains superseded by the PR_BUDGET_BASE mechanism.

[qnbs]

2026-09-13 #704-A correction-wave checkpoint: PR #739 head f35c19f carries the consolidated current-review fixes. The catalog now distinguishes the official Gemini current subset from legacy gemini-3.1-flash and opt-in preview values; persistence admission is provider-qualified and malformed-safe; generic model listing excludes the image-only entry; Gemini legacy values are no longer offered as non-persistable selector choices; Grok preview typing and OpenRouter routing/default fallbacks are aligned; and the CodeScene classifier complexity finding is reduced below the threshold. Focused 200/200 tests, typecheck, lint, docs check, PR-budget preflight, and sequential ci:prepush passed. Current budget is 28 files / 1148 meaningful lines / 3 commits. Remaining OpenRouter fallback-label localization is deferred to the existing docs/i18n authority because it would require locale fan-out outside this saturated #704-A slice. Live provider entitlement/inference/quality/streaming/image qualification remains CREDENTIAL_REQUIRED / NOT_YET_REAL_PROVIDER_QUALIFIED; no credentials or paid calls were used.