Cluster detail
reqlan rq/extension/host
Ideas located under folder reqlan rq/extension/host.
folder
53 ideas
7 files
| Idea | File | Status | Summary | Katz |
|---|---|---|---|---|
| activation | reqlan rq/extension/host/activation.rq | VS Code loads the extension host entry at ["../../../packages/extension/src/extension/main.ts"] when an activation event in ["../../../packages/extension/package.json"] matches. The exported `activate(context)` function is the single activation entry point for [scope.vscode_extension]. Install-time and first-run sequencing across extension vs base layers: ["./installation.rq".installation_sequencing]. Startup failure diagnosis, first-paint sequencing, bundle splitting, and development-host lessons: ["./startup-performance.rq"]. | 0.064 | |
| activation_events | reqlan rq/extension/host/activation.rq | Activation is declared in `contributes.activationEvents` in ["../../../packages/extension/package.json"]. - `onStartupFinished` — activate after the workbench finishes starting; ensures first-run onboarding can run without opening a `.rq` file first. - `onLanguage:reqlan` — activate when a reqlan document is opened. - `onLanguage:python`, `onLanguage:javascript`, `onLanguage:typescript`, `onLanguage:typescriptreact` — activate for comment-reference and glue-semantics support in those languages. - `onView:reqlan.activityBar` — activate when the reqlan activity bar view is opened. - `onChatParticipant:reqlan.reqlan-extension` — activate when the @ reqlan chat participant is used. - `onCommand:reqlan.*` — activate when listed reqlan palette commands run before the extension has loaded. There is no separate `onInstall` hook; install-time behaviour runs on the first activation after install. | 0.056 | |
| activation_sequence | reqlan rq/extension/host/activation.rq | `activate` is synchronous and non-blocking in ["../../../packages/extension/src/extension/main.ts"]; it never awaits startup work so the UI is available as soon as possible. It runs the following phases: 1. Register reference inlay-hint and CodeLens configuration / commands synchronously. 2. Call [analytical_submodule_activation] — registers commands, activity bar, chat, webviews, AI commands, and mutation hooks synchronously and returns without starting indexing. 3. Register import-error quick-fix commands when the analytical submodule registered. 4. Arm [first_paint_startup] so index startup cannot race the activity-bar shell. 5. Invoke [onboarding_check] without awaiting it, so onboarding cannot block activation. Submodule failures are logged and do not prevent later phases from running. | 0.077 | |
| analytical_submodule_activation | reqlan rq/extension/host/activation.rq | Analytical submodule registration is implemented in ["../../../packages/extension/src/analytical_submodule/index.ts"]. `activateAnalyticalSubmodule` is synchronous: VS Code contributions ( commands, activity bar provider, chat participant, webviews, AI commands, mutation hooks ) register synchronously and it returns the submodule immediately. It does not start indexing; it passes the activity-bar post-paint callback into the provider and the caller starts index activation through [first_paint_startup]. | 0.060 | |
| background_startup | reqlan rq/extension/host/activation.rq | Startup work that must not block activation is coordinated by `scheduleBackgroundStartup` in ["../../../packages/extension/src/extension/main.ts"]. - [first_paint_startup] gates index discovery and sync when the Context view opens; a three-second fallback preserves warm startup when the sidebar remains closed. - The language client starts after the same paint signal when the Context view opens, with a one-second fallback so language features still start when the sidebar remains closed. - Registers attribute and name catalog sync once the language client exists; the initial push covers an already-ready index and the catalog-update subscription covers indexes that become ready afterwards. Index and language-client failures are logged and do not affect the already-available UI. | 0.113 | |
| first_paint_startup | reqlan rq/extension/host/activation.rq | done | The activity-bar HTML shell is assigned by ["../../../packages/extension/src/activity_bar_module/activity-bar-webview-provider.ts"] after one event-loop turn ( retry once on invalid-state ). Host `postMessage` starts only after the webview `ready` handshake; disposed / invalid-state errors are swallowed by ["../../../packages/extension/src/shared/safe-webview-post.ts"]. Its Svelte app installs the host message listener before mount, then sends the one-shot `ready` handshake from a task queued after its first animation frame. ["../../../packages/extension/src/extension/startup-gate.ts"] resolves that handshake once; `IndexService.activate` then discovers bases and syncs. If no view opens, a bounded three-second fallback starts the index without any visible first paint to contend with. Index open / sync requires the host-matching core engine ( rusqlite ); missing `.node` fails activate. Windows claim / dispose races: ["./startup-performance.rq".webview_claim_race]. | 0.148 |
| onboarding_check | reqlan rq/extension/host/activation.rq | Post-install onboarding is checked on every activation, not via a dedicated install event. ["./onboarding/page-thanks-for-installing.rq".installation_event_trigger] is satisfied because `activate` always schedules ["../../../packages/extension/src/extension/open-thanks-for-installing.ts"] after the activity-bar paint gate or 400 ms ( ["./startup-performance.rq".webview_claim_race] ). The check reads global state key `onboarding` via ["../../../packages/extension/src/extension/onboarding-state.ts"]: - `onboardingMessageShown` — when false, open the onboarding webview panel via ["../../../packages/extension/src/extension/onboarding-panel.ts"]. - `lastVersion` — updated each activation after the message has been shown so future releases can detect extension updates. The call is fire-and-forget; errors are logged and do not fail activation. Command-palette Show Onboarding remains immediate. | 0.087 | |
| event_driven | reqlan rq/extension/host/architecture.rq | the application should be event driven. | 0.085 | |
| state_machine_mindset | reqlan rq/extension/host/architecture.rq | The application should be designed as a collection of state machines. The core index lifecycle FSM lives in the Rust runtime ( ["../../core_analysis/rust_port.rq".native_bridge] ); Svelte webview UI follows [typescript_codestyle.ui_state_management] and [typescript_codestyle.zustand_boundary] ( runes AppState, no zustand ). No JS zustand stores remain. | 0.071 | |
| ai_naming | reqlan rq/extension/host/configuration.rq | Command palette entries use category " reqlan " with unprefixed titles ( the palette renders them as " reqlan:... " ). The rq- prefix is reserved for chat slash commands and agent skills only, e. g. / rq-search and / rq-build-requirement in Cursor or @ reqlan / rq-search in VS Code Copilot. Do not put rq- or " RQ: " in command palette titles; that duplicates the visible prefix. | 0.048 | |
| configuration_import_roots | reqlan rq/extension/host/configuration.rq | `importRoots` is an optional array of alias-to-directory mappings in `.reqlan/config.json`. Each mapping has: - `alias` ( required non-empty string ): prefix before `/` in aliased import paths. - `root` ( optional non-empty string ): directory for that alias. A relative `root` resolves against the base root ( the parent of `.reqlan` ), not against the `.reqlan` directory. An absolute path or `file://` URI is used as that alias' import-root directory directly. When `root` is omitted for a mapping, that alias uses the workspace folder that contains the `.rq` file. When `importRoots` is omitted, empty, or has no valid entries, the default is one mapping with alias `importRootAlias` from ["../../../packages/analytical/src/core/defaults.json"] and no explicit root. When several aliases could match a path, the longest alias wins. Invalid or unreadable JSON, and a non-array `importRoots` value, fall back to defaults ( or no loaded config for discovery, then defaults at resolve time ). Language path forms and `@/` shorthand: ["../../language/imports.rq".import_paths] and ["../../language/imports.rq".configuration_import_root_alias]. Comment references in source files use the same mappings: ["../language/comment-references/functional-code-comment-references.rq".comment_reference_import_root_alias]. Schema: [configuration_schema_file]. Applying file discovery: [configuration_location]. Editor completion of aliased import paths: ["../language/syntax/features-syntax.rq".code_completion]. | 0.167 | |
| configuration_location | reqlan rq/extension/host/configuration.rq | An optional `.reqlan/config.json` may appear under a base's `.reqlan` directory. For a given `.rq` file, the applying base is the nearest ancestor directory that owns a `.reqlan` folder. The applying config is that base's `.reqlan/config.json` when present. If the owning base has no `config.json`, or no owning base is found, defaults from [configuration_import_roots] apply. A child base does not inherit a parent base's config. | 0.190 | |
| configuration_rqignore | reqlan rq/extension/host/configuration.rq | done | Each base may define path ignore rules in `.reqlan/.rqignore` using **gitignore syntax**. Patterns are relative to the base root ( parent of `.reqlan` ), not the `.reqlan` directory. Owned by `@reqlan/analytical` so the CLI, MCP, and extension share one filter for discovery and indexing walks. Built-in defaults always apply ( dependencies, venvs, build output, VCS / editor stores, `*.db3` / sqlite DBs and SQLite sidecars, binary globs per ["../index-host/index.rq".binary_ignore], files that have no comments per ["../index-host/index.rq".commentless_file_ignore], `*.secret.rq`, hidden entries, and `.reqlan/` itself ); the on-disk file adds or overrides via the same syntax, including `!` negation. New bases seed `.reqlan/.rqignore` with those defaults ( ["../index-host/index.rq".rqignore] ). Missing or unreadable `.rqignore` still uses built-in defaults. Location convention: [configuration_location]. Application memory: ["../index-host/index.rq".application_memory]. | 0.223 |
| configuration_schema_file | reqlan rq/extension/host/configuration.rq | done | The machine-readable JSON Schema for `.reqlan/config.json` is ["../../../packages/extension/schemas/config.schema.json"]. That file is the single authoring source. Its `$id` is the public URL `https://reqlan.com/schemas/v1/config.schema.json`. Path segment `v1` is schema compatibility version: additive keys stay on `v1`; breaking shape changes introduce `v2` and a new seed URL. The site hosts a synced copy under `/schemas/v1/` ( ["../../site/site.rq".sync_config_schema] ). The extension contributes the local schema for `**/.reqlan/config.json` via `jsonValidation` in ["../../../packages/extension/package.json"] ( offline editor path ). New bases seed `$schema` to the public `$id` ( ["./installation.rq".base_config_seed] ). `.reqlan/config.json` is a JSON object. Unknown properties are not part of the schema and are ignored when loading. `$schema` is an allowed property. | 0.105 |
| barrel_page | reqlan rq/extension/host/features-commands.rq | done | When a `.rq` page grows large, barrel it into a container: create one sibling file per top-level idea, import those files into the current page, and replace the page body with a single container idea whose name the user chooses ( default: the sanitized file basename ). Same-file sibling refs are rewritten to qualified imports in the child files. Existing page imports are copied into each child. Top-level ideasets are preserved in the container file. Behaviour lives in ["../../core-architecture.rq".analytical_package] and is exposed via [cli] / ["../../cli/cli_package.rq".commands] ( `reqlan barrel` ). Extension: file-level source code action **Barrel page into container … ** and command palette **Barrel Page** ( `reqlan.barrelPage` ) prompt for the container name, confirm, then create child files and rewrite the active page via WorkspaceEdit. Related: [file_based_code_actions] [decompose] | 0.184 |
| code_actions_ignore_error | reqlan rq/extension/host/features-commands.rq | done | A Quick Fix [code_actions] on a line with diagnostics inserts [comment_reference_ignore] ( `//rq-ignore-error` ) on the line before the error. The inserted comment uses the same indent as the error line. One action is offered per line when that line has one or more diagnostics. The action is omitted when that line is already suppressed, and when the client asks only for non-quickfix kinds. Available in `.rq` files and in a comment context in a code file ( ["../language/comment-references/functional-code-comment-references.rq".references_in_functional_code_comments] ). In `#` comments the action inserts `# //rq-ignore-error` so the line stays a comment. | 0.074 |
| command_palette | reqlan rq/extension/host/features-commands.rq | done | Extension commands should be available via the vscode command palette and configurable keyboard shortcuts. Command titles should not repeat the category prefix; use category " reqlan " with plain titles so the palette shows " Reqlan: List All Ideas ", not " Reqlan: Reqlan:... " or " RQ: RQ:... ". Commands belong to product domains; this file is the palette naming hub under host lifecycle. Agent: [agent_ai.add_to_chat]. Index host: [index_diagnostics.open_index_diagnostics]. Diff: [diff_webview]. Export: [export_functions.export_html] and siblings. Mutation: [refactor_support], [barrel_page], [decompose]. Language: [search_code_actions], [code_actions_ignore_error], [create_idea_below_idea_containing_unresolved_reference_under_cursor]. | 0.087 |
| create_idea_below_idea_containing_unresolved_reference_under_cursor | reqlan rq/extension/host/features-commands.rq | done | If a local idea reference does not resolve, a Quick Fix [code_actions] creates a new idea below the idea that contains the reference. The action uses the unresolved local idea names in the idea that contains the caret: - one unresolved name: apply `Create '<name>' below` directly - several unresolved names: offer `Create all unresolved ideas below` and one action per name Qualified file / import references are omitted. The new idea is an empty block inserted after the containing idea. | 0.074 |
| decompose | reqlan rq/extension/host/features-commands.rq | A command pallete action for decomposition. Should replace an idea with a reference to a new file that holds the old contents. Should accept multiple inputs and put them in a list. | 0.090 | |
| divide_and_conquer | reqlan rq/extension/host/features-commands.rq | A command palette action should divide and conquer the current file or selected ideaset. ( an llm prompt that takes all the context and fires off subagents ) | 0.048 | |
| exports | reqlan rq/extension/host/features-commands.rq | graph should be exportable via the [export_functions.export_webview] and format entry ideas ( [export_functions.export_html], [export_functions.export_markdown], [export_functions.export_JSON], [export_functions.export_csv], [export_functions.export_pdf] ). | 0.040 | |
| file_based_code_actions | reqlan rq/extension/host/features-commands.rq | Code actions should be available for the whole file. The should include: ( regardless of cursor positions ) - barrel page — done via [barrel_page] ( `source.barrelPage` / `reqlan.barrelPage` ) - barrel idea - decompose idea - search for references. - create idea [code_actions] | 0.064 | |
| format_page | reqlan rq/extension/host/features-commands.rq | - set the whitespace etc appropriate for the page. | 0.040 | |
| get_local_graph | reqlan rq/extension/host/features-commands.rq | A command palette action should get the local graph for the current file or selected idea ( [local_graph_analysis] ). | 0.040 | |
| open_a_random_requirement | reqlan rq/extension/host/features-commands.rq | as it sounds | 0.040 | |
| pallete_function_create_todo | reqlan rq/extension/host/features-commands.rq | A function that opens up a modal webview form allowing the user to write a rq-idea, search for references etc, and writes it to a specified output file. default folder is next to current file, but should be selectable in form. This behaviour should be configurable via ["./configuration.rq"] | 0.060 | |
| search_code_actions | reqlan rq/extension/host/features-commands.rq | done | when cursor is in a `[reference]`, there shouls be a code action to search for references to that idea. it should also allow wrapping a selected string, or the word at the cursor when in idea-body prose, as a new `[reference]`. it should open up a webview modal that shows a search dialog that allows the user to search for potential references. the search menu should preserve / show the context of the would-be reference: the rest of the containing idea, with styling, and with the selected text pulsing / styled prominently. it should support fuzzy / partial searching via [search_analysis.fuzzy_search]. it should list the closest matches in a paginated view. selecting the idea should fill / replace the reference ( or wrap the selection as `[name]` ) and an import ( if required ) appropiately The lightbulb command ( `reqlan.searchReference` ) is arg-less because VS Code caches arg-bearing code-action commands and may dispose them on refresh ( error text like Actual command not found ). At invoke time the extension resolves the site via LSP `reqlan/referenceSearchSite`, or a local parse of the active editor when the language client is not yet running — it must not fail with a false " language server is not ready " when a local site can be resolved. | 0.116 |
| toggle_indirect_references | reqlan rq/extension/host/features-commands.rq | A command palette action should toggle display of indirect references in complementary rendering and graph views. | 0.040 | |
| view_all_requirements | reqlan rq/extension/host/features-commands.rq | A command palette action should open a browsable view of all requirements in the workspace ( ["../workspace-summary/ideas_summary/webview.rq".ideas_summary] ). | 0.040 | |
| base_config_seed | reqlan rq/extension/host/installation.rq | done | New bases write `.reqlan/config.json` with `$schema` pointing at the public v1 schema URL via [create_base_impl]. Seed shape: `{"$schema":"https://reqlan.com/schemas/v1/config.schema.json"}`. Semantics and discovery of applying config: [configuration.configuration_location], [configuration.configuration_import_roots], [bases.base_configuration]. Schema / editor validation: [configuration.configuration_schema_file]. A child base does not inherit a parent base's config file. Existing bases are not rewritten ( idempotent create leaves them alone ). | 0.076 |
| base_installation | reqlan rq/extension/host/installation.rq | Base-level install marks a directory as a [bases.base] and seeds shared application memory under `<base>/.reqlan/` ( [app_memory.application_memory] ). Entry points ( same helper [create_base_impl] ): - Editor: `reqlan.createBase` / empty-state CTAs ( [bases.create_base_onboarding] ) — only after discovery finds **zero** bases; never on extension install alone. - CLI: `reqlan init [directory]` ( [cli.init] ). Idempotent: existing `.reqlan` is left alone ( `created: false` ). On **new** base creation the sequence is: 1. Create `<base>/.reqlan/` marker directory ( presence = base ). 2. Seed [base_config_seed] ( `.reqlan/config.json` ). 3. Seed [base_rqignore_seed] ( `.reqlan/.rqignore` ). 4. Seed [bases.base_initialisation_ignore] ( `.reqlan/.gitignore` for SQLite artifacts ). 5. Editor rediscovers bases and activates indexing for that base; SQLite `ideas-index.sqlite` appears when the index opens ( not necessarily written at marker creation ). Child / nested bases follow [bases.base_nesting]; each base owns its own `.reqlan` seeds and index. | 0.109 | |
| base_rqignore_seed | reqlan rq/extension/host/installation.rq | New bases write `.reqlan/.rqignore` with gitignore-syntax defaults ( dependencies, venvs, build output, DBs such as `*.db3` and SQLite sidecars, binary globs, [app_memory.commentless_file_ignore], secrets, hidden entries, `.reqlan/` itself ). Comment text in the seed: [app_memory.rqignore_initialisation]. Built-in defaults always apply even if the file is missing; the seeded file is the editable surface ( [configuration.configuration_rqignore] / [app_memory.rqignore] / [app_memory.binary_ignore] ). Used by analytical discovery and indexing walks ( CLI and extension share `@reqlan/analytical` ). | 0.071 | |
| base_vs_extension_boundary | reqlan rq/extension/host/installation.rq | Clear ownership so install steps do not write to the wrong store: - Extension package / activate / welcome webview → [extension_installation] ( extension host + `globalState` onboarding key ). - Activity bar, LSP, chat participant, Ideas Summary → extension runtime after [activation.activation_sequence]. - `.reqlan/` marker, `config.json`, `.rqignore`, `.gitignore` ( SQLite artifacts ), ideas index, index diagnostics sqlite → [base_installation] under `<base>/.reqlan/`. - Cursor `rq-*` skills + MCP json → [workspace_agent_files] under `<workspace>/.cursor/`. Do not store agent skills or MCP config inside `.reqlan`. Do not treat welcome-webview globalState as base-local memory. | 0.040 | |
| extension_installation | reqlan rq/extension/host/installation.rq | Extension-level install covers packing, activation, and first-run host UX — not base filesystem state. There is **no** VS Code `onInstall` API; install-time behaviour runs on the **first** [activation.activation] after install ( [activation.activation_events] ). Sequencing inside `activate` is owned by [activation.activation_sequence]: - Sync register CodeLens / inlay config commands. - Synchronously register analytical submodule contributions ( commands, activity bar, chat, webviews, AI commands, mutation hooks ) without starting the index ( [activation.analytical_submodule_activation] ). - Register import quick-fixes, then schedule index and language-client startup through [activation.first_paint_startup] / [activation.background_startup]; sync catalogs once the language client exists. - Fire-and-forget [activation.onboarding_check] → [welcome_webview_install]. Failures in submodule or language client are logged and must not abort later phases or the welcome check. Related command surfaces: Show Onboarding ( [welcome.show_onboarding_command] ), Install Cursor Skills ( [skills_mcp.cursor_skills_install] ), Create Base ( [bases.create_base_onboarding] ). | 0.076 | |
| installation | reqlan rq/extension/host/installation.rq | reqlan installation has **two sequenced layers** that must not be conflated: 1. [extension_installation] — host product ( VS Code / Cursor extension ) install and first activation. 2. [base_installation] — marking a filesystem directory as a reqlan [bases.base] and seeding its `.reqlan` application memory. Extension install alone does **not** create a base. Base install alone does **not** open the welcome webview or install host agent skills. CLI `init` shares the base path with the editor ( [cli.init] / [bases.create_base_onboarding] ). | 0.046 | |
| installation_sequencing | reqlan rq/extension/host/installation.rq | End-to-end first-run story ( typical editor user ): 1. User installs the extension from Marketplace / Open VSX / VSIX ( [extension_installation] ). 2. Host fires an [activation.activation_events] match ( usually `onStartupFinished` ). 3. [activation.activation_sequence] synchronously registers contributions and schedules [activation.background_startup]; [activation.onboarding_check] may open [welcome.installation_event] ( Welcome to Reqlan webview ) without blocking activation. 4. If no `.reqlan` exists under workspace folders, surfaces offer create-base ( [bases.create_base_onboarding] ) — user-driven, never auto-created on extension install. 5. [base_installation] seeds config / ignore / marker; index activate / sync follows ( [app_memory.application_memory] ). 6. Optionally, user runs Install Cursor Skills ( [workspace_agent_files] ) — copies rq-* skills and writes `.cursor/mcp.json`; independent of `.reqlan` seeding. Ordering constraint: steps 1 – 3 are extension-scoped; steps 4 – 5 are base-scoped; step 6 is workspace agent tooling scoped to the open folder, not the `.reqlan` directory. | 0.048 | |
| welcome_webview_install | reqlan rq/extension/host/installation.rq | done | The **Welcome to Reqlan** onboarding webview is the extension-install UX surface. Opened once on first activation when `onboardingMessageShown` is false ( [welcome.installation_event] / [welcome.installation_event_trigger] / [welcome.onboarding_state] ). Content: welcome copy, resolved phonebook links, syntax-highlighted example `.rq`, open-as-untitled control, activity bar / `@reqlan` tips, sponsor thanks. Must not block [activation.activation_sequence]; errors are logged only. Reopen on demand via [welcome.show_onboarding_command] without resetting shown state unless product policy changes. Implementation: ["../../../packages/extension/src/extension/open-thanks-for-installing.ts"], ["../../../packages/extension/src/extension/onboarding-panel.ts"], ["../../../packages/extension/webviews/onboarding/"]. | 0.069 |
| workspace_agent_files | reqlan rq/extension/host/installation.rq | Agent / AI host files are **workspace** artefacts, not files under `.reqlan/`. Install Cursor Skills ( [skills_mcp.cursor_skills_install] ) copies bundled `rq-*` skills into `<workspace>/.cursor/skills/` and writes `<workspace>/.cursor/mcp.json` ( [install_cursor_skills_impl] ): local `packages/mcp/bin/mcp.js` when present, otherwise `npx -y @reqlan/mcp`. Requires an open workspace folder; does not create a base and does not write into `.reqlan`. Naming: skills / chat slash commands use `rq-` prefix ( [skills_mcp.chat_skill_naming] ); command palette stays category " reqlan " ( [configuration.ai_naming] ). AI command surfaces that depend on skills being present: [agents.ai_integration], [agents.ai_build_requirement], [agents.ai_add_to_context], [agents.ai_write_plan], [agents.ai_fix_stale_references]. Dev sync of the same skill sources into this repo's `.cursor/skills` is a build concern ( ["../../development/build.rq"] ), distinct from end-user install sequencing. | 0.060 | |
| lsp_support | reqlan rq/extension/host/scope.rq | the extension should provide an lsp server for. rq files, enabling navigation, validation, and computed views across the requirement graph | 0.083 | |
| scope | reqlan rq/extension/host/scope.rq | these requirements describe the vscode extension and lsp for reqlan | 0.045 | |
| vscode_extension | reqlan rq/extension/host/scope.rq | the extension should integrate with vscode as the primary developer-user environment | 0.069 | |
| activation_events_learning | reqlan rq/extension/host/startup-performance.rq | Modern VS Code derives activation for contributed views and commands. The incident log explicitly showed activation event `onView:reqlan.activityBar`, so the missing-command failure was not caused by a missing explicit `onView` entry. Activation-event changes should be justified from host logs and target-version behavior, not used to mask a module-load exception. | 0.040 | |
| deferred_startup_sequence | reqlan rq/extension/host/startup-performance.rq | done | Required order: 1. Load the smallest practical host entry. 2. Synchronously register commands and the activity-bar provider; return from `activate`. 3. Yield one turn, assign the activity-bar shell, and wait for the post-first-frame `ready` handshake. Do not `postMessage` until `ready`. 4. Start index discovery / sync after `ready`; if the sidebar stays closed, start after a bounded three-second fallback so startup indexing and watchers are not lost. 5. Start the language client after `ready`, with a one-second fallback so language features work when the sidebar stays closed. 6. Open first-run onboarding after the same paint signal or 400 ms, so it does not race the sidebar iframe ( [webview_claim_race] ). 7. Report incremental index progress inside the already-painted sidebar. The ready signal and both startup paths are one-shot / idempotent. [activation.background_startup] | 0.046 |
| development_bundle_freshness | reqlan rq/extension/host/startup-performance.rq | done | F5 executes `package.json.main` ( `out/extension/main.cjs` ), not TypeScript source. `out/`, generated webview media, and copied syntaxes are gitignored, so launching without a build can run missing or stale artifacts even when source already contains the fix. `.vscode/launch.json` therefore uses a deterministic pre-launch task that invokes the extension build orchestrator directly; root `pnpm run build:ext` delegates to the same script. The task content-fingerprints Langium and physics generation, each webview, packaging media, and extension-host / language-server output; `tsc -b` retains project-reference incrementality. Unchanged artifacts are verified and skipped before the development host opens. Watch mode remains useful during iteration, but concurrent watchers do not restart an already-running extension host or language-server child; stop and start F5 after host / server changes. ["../../../.vscode/launch.json"] ["../../../.vscode/tasks.json"] | 0.046 |
| extension_host_process_model | reqlan rq/extension/host/startup-performance.rq | One Node extension-host process for the development window is normal; multiple workers are not required for a healthy Reqlan activation. The language server is a separate child process launched only after extension activation reaches `LanguageClient.start()`. Therefore an idle extension host with no Reqlan language-server child is consistent with an earlier module-load / activation failure, not evidence that a worker is missing. | 0.040 | |
| extension_startup_reliability | reqlan rq/extension/host/startup-performance.rq | done | Reqlan startup must make the activity-bar shell and contributed commands available before optional indexing, parser construction, database initialization, or language-client startup can monopolize the extension host. The implementation contract is [first_paint_contract], [webview_claim_race], [deferred_startup_sequence], [lazy_runtime_dependencies], and [development_bundle_freshness]. Operational diagnosis follows [startup_diagnostics]. [activation.activation_sequence] [activitybar.loading_state] [indexer.nonblocking_index] [build.extension_bundle] | 0.046 |
| first_paint_contract | reqlan rq/extension/host/startup-performance.rq | done | The platform spinner ends only after VS Code loads the host module, calls `activate`, the provider registers, and `resolveWebviewView` assigns HTML. `resolveWebviewView` is async: it binds the view, yields one turn so the overlay can be claimed, then assigns the lightweight HTML / Svelte shell ( retry once on invalid-state ). It does **not** `postMessage` in that method. The webview installs its host message listener, mounts, waits for its first animation frame, then posts the one-shot `ready` signal from a queued task. Host messages start only after that handshake. Index discovery / sync waits for the same signal so synchronous parser or database setup cannot race the first visible frame. Windows overlay restore can dispose and re-resolve the sidebar; the provider rebinds and waits for a new `ready`. [activation.first_paint_startup] [webview_claim_race] ["../../../packages/extension/webviews/activity-bar/App.svelte"] ["../../../packages/extension/webviews/activity-bar/state/app.svelte.ts"] ["../../../packages/extension/src/extension/startup-gate.ts"] ["../../../packages/extension/src/shared/safe-webview-post.ts"] | 0.058 |
| invalid_url_activation_failure | reqlan rq/extension/host/startup-performance.rq | done | The concrete incident failed while requiring `out/extension/main.cjs`, before `activate()` ran: `TypeError: Invalid URL` in `embedPhysicsCoreSource`. Runtime `readFileSync(new URL(..., import.meta.url))` is unsafe when esbuild emits CommonJS for an ES2017 target: `import.meta.url` is unavailable / empty and source-relative assets do not exist beside the bundled entry. The HTML export used to embed physics via `html-export-assets.ts` `embedPhysicsCoreSource`. That writer is gone; export now inlines assets from ["../../../crates/reqlan-export/assets/app.js"]. Code that still needs a module directory or `createRequire` ( core engine loader and parse worker ) must not mention `import.meta` statically in a way that esbuild CJS empties: prefer CJS `__dirname` / `__filename` when those exist ( extension host bundle ), and `import.meta.url` on the Node ESM path ( CLI / MCP ). The host esbuild step defines `import.meta.url` as `import_meta_url` from this file's `__filename` so the CJS bundle stays valid and does not warn `empty-import-meta`. CLI / MCP keep the TypeScript `import.meta.url` emit. Do not eval `import.meta.url` — Node 24 treats that as a script eval and throws `Cannot use 'import.meta' outside a module`. ["../../../packages/analytical/src/native/load-native.ts"] ["../../../packages/language/src/reqlan-async-parser.ts"] ["../../../packages/extension/esbuild.mjs"] | 0.040 |
| lazy_runtime_dependencies | reqlan rq/extension/host/startup-performance.rq | done | Base discovery must be cheap: - Constructing `WorkspaceIndex` does not construct Langium / Chevrotain services; index sync uses the core native engine ( rusqlite ). - The host-matching `reqlan_napi` `.node` is required at activate; there is no sql. js vendor bundle in the extension host. - Export / physics source is generated at build time rather than read via extension-runtime URLs. ["../../../packages/analytical/src/index-store/workspace-index.ts"] ["../../../packages/analytical/src/index-store/sqlite-store.ts"] ["../../../packages/analytical/src/index-store/index-diagnostics-store.ts"] ["../../../packages/extension/esbuild.mjs"] | 0.046 |
| observed_failure | reqlan rq/extension/host/startup-performance.rq | Failure signature: - Reqlan contributes its activity-bar container and header buttons from `package.json`, but the Context view remains on VS Code's built-in spinner before the extension-owned " Loading Reqlan … " shell. - Contributed commands may be visible as menu items yet fail with `command 'reqlan.*' not found`. - The extension-host CPU profile can be mostly idle after the failure. This combination means static manifest contributions loaded but the extension module failed before `activate()` registered command handlers and the webview provider. | 0.040 | |
| startup_diagnostics | reqlan rq/extension/host/startup-performance.rq | Diagnosis order: 1. Read the development extension host's `remoteexthost.log`; find `ExtensionService#_doActivateExtension reqlan.reqlan-extension`. 2. Distinguish code-loading time, activate-call time, and activate-resolved time. 3. If activation failed, use the first Reqlan stack frame rather than inferring a CPU hang. 4. If manifest UI exists but every command is missing, investigate module load / activation before indexing or webview data. 5. If the extension-owned " Loading Reqlan … " shell appears, provider resolution succeeded; subsequent delays belong to webview bootstrap or index readiness. 6. Confirm `out/extension/main.cjs` is newer than changed source and includes a lazy vendor sql-asm import. CPU-idle profiles do not disprove activation failure: once `require()` throws, the host can remain healthy and mostly idle while Reqlan stays unregistered. | 0.046 | |
| verification_contract | reqlan rq/extension/host/startup-performance.rq | done | Startup changes are complete only when: - The production extension build succeeds and emits `out/extension/main.cjs`. - The main bundle does not embed a sql. js vendor; index open requires the core native engine. - Extension startup-gate, webview-claim, and analytical lazy-service tests pass. - Activity-bar shell paint is visually checked in a newly restarted F5 development host; activation failures are cached for the lifetime of a failed host session. - Requirement analysis resolves the updated startup graph. | 0.040 |
| webview_claim_race | reqlan rq/extension/host/startup-performance.rq | done | Setting `webview.html` or calling `postMessage` before the workbench has claimed the overlay ( or after it has disposed it ) can fail with `Webview is in an invalid state` / `Webview is disposed`. This is intermittent and more common on Windows during extension init, when the activity-bar view is restored in the same tick as another webview ( first-run onboarding ). Contract: - Activity-bar host posts only after the webview's `ready` signal; `post` is a no-op until then and swallows disposed / invalid-state errors. - `resolveWebviewView` may run more than once: dispose prior view listeners, clear `webviewReady`, rebind, reassign HTML. - First-run onboarding waits for the activity-bar paint gate or 400 ms, whichever first, so it does not register a second webview service worker during sidebar claim. Palette `reqlan.showOnboarding` stays immediate. Index and language-client startup still use the existing paint / timeout fallbacks — a dead sidebar must not strand indexing. [first_paint_contract] [activation.onboarding_check] ["../../../packages/extension/src/activity_bar_module/activity-bar-webview-provider.ts"] ["../../../packages/extension/src/extension/main.ts"] ["../../../packages/extension/src/shared/safe-webview-post.ts"] | 0.091 |
Cluster graph
Initialising graph…