@reticlehq/init 3.2.0 → 3.4.0

package/dist/run.js

@@ -6,23 +6,30 @@
 import { OnboardingPhase, OnboardingStepStatus } from '@reticlehq/core/telemetry';
 import { detectMcpClients } from './register/detect-clients.js';
 import { dirname, join } from 'node:path';
-import { CONTAINER_MARKERS } from './diagnose/containerised-dev-server.js';
+import { CONTAINER_MARKERS, runsDevServer } from './diagnose/containerised-dev-server.js';
+import { explainInstallFailure } from './diagnose/install-retries.js';
 import { CSP_FILES } from './diagnose/csp-doctor.js';
-import { preflightRefusal } from './plan/preflight.js';
-import { detectDjangoProject, detectStreamlitProject, djangoSetupMessage, noPackageJsonMessage, streamlitSetupMessage, } from './detect/non-js-project.js';
-import { devCommandFrom } from './detect/dev-script.js';
+import { preflight } from './plan/preflight.js';
+import { devCommandFrom, devScriptBody } from './detect/dev-script.js';
 import { restartHint, FEEDBACK_HINT } from './diagnose/closing-hint.js';
 import { projectIdOf, rememberProjectOnDisk } from './project/remember-project.js';
-import { detect, Framework, UiLibrary } from './detect/detect.js';
+import { ANGULAR_WORKSPACE_FILE, detect, FORGE_RENDERER_CONFIGS, Framework, UiLibrary, } from './detect/detect.js';
+import { ANGULAR_PROXY_PATH, angularEntry } from './patch/angular.js';
+import { HTML_INDEX_PATH } from './patch/static-page.js';
+import { initWithoutPackageJson } from './no-package-json.js';
 import { wasMcpRegistered } from './register/mcp-registered.js';
 import { pickAstroHost } from './patch/astro-host.js';
 import { ELECTRON_VITE_CONFIG_CANDIDATES, NEXT_CONFIG_CANDIDATES, PACKAGE_JSON, VITE_CONFIG_CANDIDATES, } from './detect/workspace-apps.js';
 import { redirectToWorkspaceApp } from './detect/workspace-redirect.js';
+import { enclosingWorkspaceRoot } from './detect/workspace-apps.js';
 import { isConnectStep } from './plan/connect-steps.js';
 import { CURSOR_RULE_PATH, RETICLE_MD_PATH } from './project/agent-rules.js';
+import { CLAUDE_SETTINGS_PATH } from './plan/stop-hook-step.js';
 import { CRA_ENV_PATH } from './patch/cra.js';
 import { NEXT_LAYOUT_CANDIDATES, NEXT_PAGES_APP_CANDIDATES } from './patch/next-patch.js';
 import { formatGeneratedSource } from './patch/format-generated.js';
+import { tanstackStartConnectPath } from './patch/tanstack-start.js';
+import { installedViteMajor } from './patch/vite-owning-config.js';
 /** CRA's bundled entry, in the order create-react-app itself generates them. */
 const CRA_ENTRY_CANDIDATES = ['src/index.tsx', 'src/index.jsx', 'src/index.ts', 'src/index.js'];
 function craEntryOf(io) {
@@ -34,12 +41,12 @@ function craEntryOf(io) {
     return null;
 }
 import { DEPS_TARGET, RETICLE_CONFIG_FILE, frameworkPackages, MCP_TARGET, buildPlan, StepStatus, } from './plan/plan.js';
-import { claudeAvailableProbe, claudeExistsProbe } from './register/mcp.js';
+import { claudeAvailableProbe, claudeHasReticle } from './register/mcp.js';
 import { reticleDevLocation } from './patch/next-patch.js';
 import { scanTestids, storeHints, scanStores } from './detect/capabilities.js';
-import { CURSOR_PROJECT_MARKER } from './register/mcp-clients.js';
+import { CLAUDE_PROJECT_CONFIG, CURSOR_PROJECT_MARKER } from './register/mcp-clients.js';
 import { deriveProjectId, packageName } from './project/project-id.js';
-import { VITE_DEV_MODULE_PATH, ELECTRON_VITE_DEV_MODULE_PATH, connectArgWithToken, nuxtPluginPath, staticPageSnippet, djangoMiddlewareSnippet, reticleConfigContent, streamlitPageSnippet, } from './patch/snippets.js';
+import { VITE_DEV_MODULE_PATH, ELECTRON_VITE_DEV_MODULE_PATH, nuxtPluginPath, } from './patch/snippets.js';
 import { NUXT_CONFIG_CANDIDATES } from './patch/nuxt-patch.js';
 import { CLAUDE_COMMAND_PATH, CURSOR_COMMAND_PATH } from './register/slash-command.js';
 import { RETICLE_VERSION } from './version.js';
@@ -218,6 +225,17 @@ function agentRootOf(options) {
     const root = options.agentRoot;
     return root === undefined || root === options.cwd ? undefined : root;
 }
+/** What the Angular steps read: the workspace file, the entry it names, and our proxy module. */
+function angularInputs(io) {
+    const workspace = io.readFile(ANGULAR_WORKSPACE_FILE);
+    const entryPath = angularEntry(workspace);
+    const entry = io.readFile(entryPath);
+    return {
+        angularWorkspace: null === workspace ? null : { path: ANGULAR_WORKSPACE_FILE, source: workspace },
+        angularEntry: null === entry ? null : { path: entryPath, source: entry },
+        angularProxySource: io.readFile(ANGULAR_PROXY_PATH),
+    };
+}
 function gatherPlanInput(options, io, pkg) {
     // Stable identity derived from the app's package.json name + root, so it survives port changes.
     const projectId = deriveProjectId(packageName(pkg), options.cwd);
@@ -233,7 +251,11 @@ function gatherPlanInput(options, io, pkg) {
         nodeModulesMarkers,
     };
     const detection = detect(detectInput);
-    const vitePath = firstPresent(rootFiles, VITE_CONFIG_CANDIDATES);
+    // Forge has no `vite.config.*`; its renderer config IS the Vite config the plugin belongs in, and
+    // handing it over under that name is what lets the ordinary Vite patcher do the work.
+    const vitePath = firstPresent(rootFiles, Framework.ELECTRON_FORGE === detection.framework
+        ? FORGE_RENDERER_CONFIGS
+        : VITE_CONFIG_CANDIDATES);
     const viteSource = null === vitePath ? null : io.readFile(vitePath);
     const viteConfig = vitePath !== null && viteSource !== null ? { path: vitePath, source: viteSource } : null;
     const electronVitePath = firstPresent(rootFiles, ELECTRON_VITE_CONFIG_CANDIDATES);
@@ -247,8 +269,8 @@ function gatherPlanInput(options, io, pkg) {
     // global config file. Only probe when the MCP step is in play.
     const availableProbe = claudeAvailableProbe();
     const claudeCli = options.mcp ? io.probe(availableProbe.command, availableProbe.args) : false;
-    const existsProbe = claudeExistsProbe();
-    const mcpExists = claudeCli ? io.probe(existsProbe.command, existsProbe.args) : false;
+    // Read from Claude's config, never `claude mcp get`: that launches the server — see claudeHasReticle.
+    const mcpExists = claudeCli ? claudeHasReticle(io, io.cwd()) : false;
     // Every MCP client this machine shows evidence of. Conservative and one-directional: we write
     // into a config a client ALREADY has, and never create ~/.gemini or ~/.codeium for somebody who
     // does not use them.
@@ -294,9 +316,12 @@ function gatherPlanInput(options, io, pkg) {
     return {
         detection,
         captureBodies: options.captureBodies,
+        hooks: options.hooks,
         cspSources,
         claudeCli,
         mcpExists,
+        insideClaudeCode: io.host.insideClaudeCode(),
+        claudeProjectConfig: options.mcp ? io.readFile(agentFile(CLAUDE_PROJECT_CONFIG)) : undefined,
         platform: process.platform,
         detectedClients,
         cursorProjectPresent: io.exists(CURSOR_PROJECT_MARKER),
@@ -304,7 +329,13 @@ function gatherPlanInput(options, io, pkg) {
         // repo that containerises it — `frontend/` under a root `docker-compose.yml` is the shape this
         // came from. Only the first match is reported; the note is the same whichever file found it.
         ...(() => {
-            const marker = CONTAINER_MARKERS.find((name) => io.exists(name) || io.exists(join('..', name)));
+            // Only a file that RUNS the dev server: a production-only image is the common case, and
+            // React Router's template ships one. See runsDevServer.
+            const devScript = devScriptBody(pkg);
+            const marker = CONTAINER_MARKERS.find((name) => [name, join('..', name)].some((path) => {
+                const content = io.readFile(path);
+                return null !== content && runsDevServer(name, content, devScript);
+            }));
             return marker === undefined ? {} : { containerMarker: marker };
         })(),
         viteConfig,
@@ -316,6 +347,7 @@ function gatherPlanInput(options, io, pkg) {
             ? { path: layoutRelPath, source: astroLayoutSource }
             : null,
         astroEnvDts: io.readFile('src/env.d.ts'),
+        astroReticleDev: io.readFile('src/components/ReticleDev.ts'),
         nextConfigFile,
         nextConfigSource: null === nextConfigFile ? null : io.readFile(nextConfigFile),
         nextLayout: layoutPath !== null && layoutSource !== null
@@ -323,7 +355,7 @@ function gatherPlanInput(options, io, pkg) {
             : null,
         // Capabilities: scanned, never asked for. Bounded — a hint for the agent, not a repo index.
         testids: scanTestids(sourceFiles.map((f) => f.source)),
-        storeHints: storeHints(dependencyNames(pkg)),
+        storeHints: storeHints(dependencyNames(pkg), sourceFiles),
         foundStores: scanStores(sourceFiles, dependencyNames(pkg)),
         nextFoundStores: scanStores(sourceFiles, dependencyNames(pkg), dirname(devLocation.path)),
         viteDevModuleExists: io.exists(detection.framework === Framework.ELECTRON_VITE
@@ -334,6 +366,7 @@ function gatherPlanInput(options, io, pkg) {
         nextReticleDevExists: io.exists(devLocation.path),
         nextReticleDevSource: io.readFile(devLocation.path),
         svelteKitHooksExists: io.exists(SVELTEKIT_HOOKS),
+        svelteKitHooksSource: io.readFile(SVELTEKIT_HOOKS),
         reactRouterEntryExists: io.exists(REACT_ROUTER_ENTRY),
         // The SOURCE, so an entry the app already owns is ADDED TO rather than replaced — it is an
         // override of React Router's default, and everything in it is load-bearing.
@@ -342,8 +375,24 @@ function gatherPlanInput(options, io, pkg) {
             ? { path: nuxtConfigPath, source: nuxtConfigSource }
             : null,
         nuxtHasAppDir,
+        viteMajor: installedViteMajor(io, detectInput.pkg),
         nuxtPluginExists: io.exists(nuxtPluginPath(nuxtHasAppDir)),
-        tanstackStartRoot: TANSTACK_START_ROOT_CANDIDATES.find((file) => io.exists(file)),
+        nuxtPluginSource: io.readFile(nuxtPluginPath(nuxtHasAppDir)),
+        ...(() => {
+            const root = TANSTACK_START_ROOT_CANDIDATES.find((file) => io.exists(file));
+            return root === undefined
+                ? {}
+                : {
+                    tanstackStartRoot: root,
+                    tanstackStartRootSource: io.readFile(root),
+                    tanstackStartConnectExists: io.exists(tanstackStartConnectPath(root)),
+                    tanstackStartConnectSource: io.readFile(tanstackStartConnectPath(root)),
+                };
+        })(),
+        ...(Framework.ANGULAR === detection.framework ? angularInputs(io) : {}),
+        ...(Framework.HTML === detection.framework
+            ? { htmlIndexSource: io.readFile(HTML_INDEX_PATH) }
+            : {}),
         craEntry: craEntryOf(io),
         craEnv: io.readFile(CRA_ENV_PATH),
         pairingToken: io.host.pairingToken(),
@@ -360,6 +409,8 @@ function gatherPlanInput(options, io, pkg) {
         cursorRuleContent: io.readFile(agentFile(CURSOR_RULE_PATH)),
         claudeCommandContent: io.readFile(agentFile(CLAUDE_COMMAND_PATH)),
         cursorCommandContent: io.readFile(agentFile(CURSOR_COMMAND_PATH)),
+        // Read only to MERGE into: the settings file is the user's, and other tools write in it too.
+        claudeSettingsContent: true === options.hooks ? io.readFile(agentFile(CLAUDE_SETTINGS_PATH)) : undefined,
         ...(agentRoot === undefined
             ? {}
             : {
@@ -381,7 +432,7 @@ function gatherPlanInput(options, io, pkg) {
 /** pnpm's workspace declaration, read when present — it is authoritative about where packages live. */
 const SKIPPED_DETAIL = 'skipped — the dependency install above failed, and wiring the app to a package that is not ' +
     'installed stops it booting. Run that install, then re-run `reticle init`.';
-function report(plan, dryRun, failed, skipped, degraded, io, projectDir, agentRoot, 
+function report(plan, dryRun, failed, skipped, degraded, why, io, projectDir, agentRoot, 
 /** The project's own dev command, so the closing line names what a human would type. */
 devCommand, 
 /**
@@ -393,6 +444,20 @@ devCommand,
  */
 continuesToRuntime = false) {
     io.print(dryRun ? 'reticle init (dry run, no files written)' : 'reticle init');
+    /*
+     * The escape hatches, named by the command that needs them, at the moment it needs them.
+     *
+     * `--dry-run`, `--app` and `--no-mcp` all exist and all work, and they were discoverable only
+     * from `--help`. A prospective user's agent refused to run this at all — correctly, since it was
+     * being asked to let a third-party package edit a build config and register itself with every
+     * agent on the machine, and nothing it could see offered a way to look first. It had already
+     * decided by the time `--help` would have told it.
+     *
+     * On the REAL run only. In a dry run the reader has already found the flag.
+     */
+    if (!dryRun) {
+        io.print('  --dry-run previews · --app <dir> picks the app · --no-mcp skips agent registration');
+    }
     // Every path below is printed RELATIVE, and until now nothing said what to. Reported from the
     // field as "[✓] Reticle config → .reticle.json" followed by the file not being there: the app was
     // in `frontend/`, init redirected into it, and the report's `.reticle.json` was true about a
@@ -426,7 +491,7 @@ continuesToRuntime = false) {
         const detail = skipped.has(s.target)
             ? SKIPPED_DETAIL
             : downgraded && s.exec !== undefined
-                ? `step failed — run manually: ${s.exec.fallback}`
+                ? (why.get(s.target) ?? `step failed — run manually: ${s.exec.fallback}`)
                 : s.detail;
         io.print(`  [${STATUS_SYMBOL[status]}] ${s.title} → ${s.target}`);
         if (status === StepStatus.APPLY)
@@ -499,7 +564,8 @@ function sdkPackagesPresent(framework, uiLibrary, io) {
     return (packages.length > 0 &&
         packages.every((p) => io.exists(`${NODE_MODULES_DIR}/${p}/${PACKAGE_JSON}`)));
 }
-function applyEffects(plan, io) {
+function applyEffects(plan, io, packageManager) {
+    const why = new Map();
     const failed = new Set();
     const skipped = new Set();
     const degraded = new Map();
@@ -573,8 +639,12 @@ function applyEffects(plan, io) {
             failed.add(s.target);
             // A failed install only blocks the wiring when the packages are genuinely ABSENT. See
             // sdkPackagesPresent: the guard protects "the import resolves", not "our subprocess exited 0".
-            if (s.target === DEPS_TARGET)
+            if (s.target === DEPS_TARGET) {
                 installFailed = true;
+                const explained = explainInstallFailure(io, packageManager, exec, s.detail);
+                if (explained !== undefined)
+                    why.set(s.target, explained);
+            }
         }
     }
     // Where this project lives, remembered for a daemon that will be started somewhere else.
@@ -588,7 +658,7 @@ function applyEffects(plan, io) {
     if (projectId !== undefined) {
         rememberProjectOnDisk(io, projectId, io.cwd(), Date.now());
     }
-    return { failed, skipped, degraded };
+    return { failed, skipped, degraded, why };
 }
 /**
  * Which STEP failed, from the step targets — not from an error string, which would carry paths.
@@ -605,8 +675,20 @@ function classifyInitFailure(failed) {
         return InitFailure.MCP_REGISTRATION;
     return InitFailure.OTHER;
 }
+/**
+ * Where the agent stands when `init` runs inside a workspace package: the workspace root.
+ *
+ * The same answer `--app` from the root already gives (see enterApp), so both routes into one app
+ * leave the root in one state — a pointer config and the agent files an agent opened there reads.
+ */
+function withWorkspaceRoot(options, io) {
+    if (options.agentRoot !== undefined || true === options.redirected)
+        return options;
+    const root = enclosingWorkspaceRoot(options.cwd, io);
+    return root === undefined ? options : { ...options, agentRoot: root };
+}
 export function runInit(options, io) {
-    const result = runInitSteps(options, io);
+    const result = runInitSteps(withWorkspaceRoot(options, io), io);
     // The ask goes here, not in report(): report() is only the success-shaped path, and the exits that
     // matter most are the ones that never reach it — no package.json, an ambiguous workspace — where
     // setup died before anything ran and the person holding the report has the least to go on. This
@@ -614,7 +696,10 @@ export function runInit(options, io) {
     //
     // `redirected` is what keeps it to ONE print: wiring an app in a monorepo re-enters runInit for the
     // chosen directory, and the inner call must not ask again.
-    if (true !== options.redirected) {
+    //
+    // And not when the runtime follows: it asks once it has finished, as the last thing printed,
+    // rather than here in the middle, before the dev server has even started.
+    if (true !== options.redirected && true !== options.continuesToRuntime) {
         io.print('');
         io.print(FEEDBACK_HINT);
     }
@@ -671,52 +756,8 @@ function runInitSteps(options, io) {
     const redirectedEarly = redirectToWorkspaceApp(options, io, pkgRaw ?? {}, runInit);
     if (redirectedEarly !== null)
         return redirectedEarly;
-    if (null === pkgRaw) {
-        const streamlit = detectStreamlitProject((file) => io.readFile(file), io.rootFiles());
-        // Asked only when Streamlit already said no, so the two can never both claim the page.
-        const django = !streamlit &&
-            detectDjangoProject((file) => io.exists(join(options.cwd, file)), io.rootFiles());
-        io.print(
-        // Two genuinely different situations used to share one sentence: a JS developer in the wrong
-        // directory, and a project that is not JavaScript at all. The second reads the old wording as
-        // a path problem and goes looking for a directory that cannot exist — reported from a
-        // Streamlit app, where the search continued into hunting for a browser bundle to inject by
-        // hand before the real answer surfaced.
-        streamlit
-            ? streamlitSetupMessage()
-            : django
-                ? djangoSetupMessage()
-                : noPackageJsonMessage((file) => io.exists(join(options.cwd, file))));
-        // The message says "add the snippet below". Print the snippet, or the message is the same
-        // broken promise in the other direction. `connectArg` carries the port; there is no projectId
-        // to bake, because a projectId is derived from the package.json that does not exist here.
-        // Scope the project on disk before printing anything, so the daemon can serve this page.
-        //
-        // This path used to print and exit, leaving no `.reticle.json` at all — and the reporter who
-        // asked for the Django path had to hand-write one alongside the middleware. Without it the
-        // daemon has no config in its own directory, refuses the page's dial, and every downstream
-        // symptom points somewhere other than the cause (see #685). The projectId derivation already
-        // handles the no-package case: it falls back to the root folder name, fingerprinted by the
-        // absolute path so two checkouts stay distinct.
-        //
-        // Written only when absent. A config a user or an earlier run already placed here is theirs.
-        const nonJsProjectId = deriveProjectId(undefined, io.cwd());
-        if (!io.exists(RETICLE_CONFIG_FILE)) {
-            io.writeFile(RETICLE_CONFIG_FILE, reticleConfigContent(Framework.HTML, options.port, nonJsProjectId, io.host.installSource()));
-            rememberProjectOnDisk(io, nonJsProjectId, io.cwd(), Date.now());
-            io.print(`Wrote ${RETICLE_CONFIG_FILE} (project "${nonJsProjectId}").`);
-        }
-        const connect = connectArgWithToken(options.port, nonJsProjectId, io.host.pairingToken());
-        io.print(streamlit
-            ? streamlitPageSnippet(connect)
-            : django
-                ? djangoMiddlewareSnippet(connect)
-                : staticPageSnippet(connect));
-        // The onboarding funnel had NO instrumentation, so a setup that died here was indistinguishable
-        // from someone who never ran the command — the two failure modes with the most different fixes.
-        io.host.reportOutcome({ ok: false, reason: InitFailure.NO_PACKAGE_JSON });
-        return { ok: false, applied: 0, manual: 0 };
-    }
+    if (null === pkgRaw)
+        return initWithoutPackageJson(options, io);
     // Init is the flow a user experiences the wait of personally, and the fixture gate measures it at
     // 1–6s per app with no explanation of the spread. These three spans split that number into detect
     // (filesystem probing), plan (pure), and apply (writes + package-manager and CLI subprocesses).
@@ -726,23 +767,32 @@ function runInitSteps(options, io) {
     // the app in frontend/ uses pnpm, and checking the file refused a scaffold the install gate proves
     // must succeed. Both conditions make every later phase fail, and each arrives far from its cause
     // when it is not checked here. See preflight.ts.
-    const refusal = preflightRefusal({
+    const preflightIo = {
         cwd: () => io.cwd(),
         canWrite: () => io.canWrite(),
         probe: (command, args) => io.probe(command, args),
-    }, planInput.detection.packageManager, { alreadyServed: options.url !== undefined && '' !== options.url });
-    if (refusal !== undefined) {
-        io.print(refusal);
+    };
+    const resolved = preflight(preflightIo, planInput.detection.packageManager, {
+        alreadyServed: options.url !== undefined && '' !== options.url,
+    });
+    if (resolved.refusal !== undefined) {
+        io.print(resolved.refusal);
         return { ok: false, applied: 0, manual: 1 };
     }
+    // The prefix that can actually run it on THIS machine — `pnpm`, or `corepack pnpm` where preflight
+    // just proved only corepack can. Threaded onto detection (never recomputed by `detect`, which is
+    // pure and never probes) so the install step, its retries and the dev command all spawn and print
+    // the same thing preflight just confirmed works, instead of a bare binary it already ruled out.
+    const packageManagerCommand = resolved.command;
+    planInput.detection = { ...planInput.detection, packageManagerCommand };
     const plan = io.host.span('init.plan', {}, () => buildPlan(planInput));
     const effects = options.dryRun
-        ? { failed: new Set(), skipped: new Set(), degraded: new Map() }
-        : io.host.span('init.apply', { steps: plan.steps.length }, () => applyEffects(plan, io));
-    const { failed, skipped, degraded } = effects;
+        ? { failed: new Set(), skipped: new Set(), degraded: new Map(), why: new Map() }
+        : io.host.span('init.apply', { steps: plan.steps.length }, () => applyEffects(plan, io, planInput.detection.packageManager));
+    const { failed, skipped, degraded, why } = effects;
     // The project's own dev command, so the closing line names what a human would actually type.
-    const devCommand = devCommandFrom(pkgRaw, planInput.detection.packageManager);
-    const result = report(plan, options.dryRun, failed, skipped, degraded, io, options.cwd, agentRootOf(options), devCommand, true === options.continuesToRuntime);
+    const devCommand = devCommandFrom(pkgRaw, packageManagerCommand);
+    const result = report(plan, options.dryRun, failed, skipped, degraded, why, io, options.cwd, agentRootOf(options), devCommand, true === options.continuesToRuntime);
     // A dry run is a preview, not an outcome — reporting it would inflate both success and failure.
     if (options.dryRun)
         return result;
@@ -810,8 +860,12 @@ function runInitSteps(options, io) {
         stack: plan.framework,
         ...(result.ok ? {} : { reason: classifyInitFailure(failed) }),
     });
+    // A failed dependency install skipped every wiring step, so there is no instrumented app to boot:
+    // without a context the runtime stops at this report, rather than starting the dev server and
+    // diagnosing an SDK that was never installed as a dev server that needs restarting.
+    const handover = failed.has(DEPS_TARGET) ? {} : { context };
     if (true === options.deferOutcome)
-        return { ...result, context, outcome };
+        return { ...result, ...handover, outcome };
     io.host.reportOutcome(outcome);
-    return { ...result, context };
+    return { ...result, ...handover };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reticlehq/init",
-  "version": "3.2.0",
+  "version": "3.4.0",
   "description": "Reticle project scaffolder — detects the framework, writes the config, patches the build and registers the MCP server. The build-time half of `reticle init`.",
   "type": "module",
   "main": "./dist/index.js",
@@ -13,7 +13,7 @@
     "./package.json": "./package.json"
   },
   "dependencies": {
-    "@reticlehq/core": "3.2.0"
+    "@reticlehq/core": "3.4.0"
   },
   "license": "FSL-1.1-ALv2",
   "author": "Reticle contributors",
@@ -27,8 +27,7 @@
   "files": [
     "dist",
     "README.md",
-    "LICENSE",
-    "NOTICE"
+    "LICENSE"
   ],
   "sideEffects": false,
   "keywords": [

package/NOTICE

@@ -1,5 +0,0 @@
-Reticle
-Copyright 2026 Reticle Labs
-
-This product includes software developed at Reticle Labs.
-Licensed under the Apache License, Version 2.0.