overmux 0.0.4 → 0.0.5

package/src/public/config.ts

@@ -11,40 +11,51 @@ export type InstanceContext = {
   getDeepLinkPrefix: () => string;
 };
 
-export type HandlerContext = {
+type ResourceInputMap = Readonly<Record<string, unknown>>;
+
+// Keep IDs paired with their raw inputs when checking calls and reusable handlers.
+type InvalidationArguments<TInputs extends ResourceInputMap> = {
+  [TId in keyof TInputs & string]: [resourceId: TId, input?: TInputs[TId]];
+}[keyof TInputs & string];
+
+export type HandlerContext<TInputs extends ResourceInputMap = {}> = {
   instance: InstanceContext;
-  invalidate: (contract: ResourceContract, input?: unknown) => void;
+  invalidate: (...args: InvalidationArguments<TInputs>) => void;
   signal: AbortSignal;
 };
 
-export type OperationContext = HandlerContext & {
-  notifications: Notifications;
-};
+export type OperationContext<TInputs extends ResourceInputMap = {}> =
+  HandlerContext<TInputs> & {
+    notifications: Notifications;
+  };
 
 export type OperationDefinition<
   TInput extends z.ZodType = z.ZodType,
   TOutput extends z.ZodType = z.ZodVoid,
+  TContext = OperationContext,
 > = {
   handle: (
     input: z.output<TInput>,
-    context: OperationContext,
+    context: TContext,
   ) => Promise<z.input<NoInfer<TOutput>>> | z.input<NoInfer<TOutput>>;
   input: TInput;
   output: TOutput;
 };
 
+// Infer schemas from this definition, not a surrounding operation map's broad constraint.
 export const defineOperation = <
   TInput extends z.ZodType,
   TOutput extends z.ZodType = z.ZodVoid,
+  TContext = OperationContext,
 >({
   handle,
   input,
   output,
 }: {
-  handle: OperationDefinition<TInput, TOutput>["handle"];
+  handle: OperationDefinition<TInput, TOutput, TContext>["handle"];
   input: TInput;
   output?: TOutput;
-}): OperationDefinition<TInput, TOutput> => ({
+}): OperationDefinition<NoInfer<TInput>, NoInfer<TOutput>, TContext> => ({
   handle,
   input,
   output: (output ?? z.void()) as TOutput,
@@ -53,26 +64,28 @@ export const defineOperation = <
 export type QueryResourceDefinition<
   TInput extends z.ZodType = z.ZodType,
   TOutput extends z.ZodType = z.ZodType,
+  TContext = HandlerContext,
 > = {
   contract: ResourceContract<TInput, TOutput>;
   kind: "query";
   read: (
     input: z.output<TInput>,
-    context: HandlerContext,
+    context: TContext,
   ) => Promise<z.input<NoInfer<TOutput>>> | z.input<NoInfer<TOutput>>;
 };
 
 export type SubscriptionResourceDefinition<
   TInput extends z.ZodType = z.ZodType,
   TOutput extends z.ZodType = z.ZodType,
+  TContext = HandlerContext,
 > = {
   contract: ResourceContract<TInput, TOutput>;
   kind: "subscription";
-  read: QueryResourceDefinition<TInput, TOutput>["read"];
+  read: QueryResourceDefinition<TInput, TOutput, TContext>["read"];
   subscribe: (
     input: z.output<TInput>,
     invalidate: () => void,
-    context: HandlerContext,
+    context: TContext,
   ) => RuntimeDisposer;
 };
 
@@ -93,8 +106,16 @@ export type DerivedResourceDefinition<
 type AnyZodType = z.ZodType<any, any, any>;
 
 export type ResourceDefinition =
-  | QueryResourceDefinition<AnyZodType, AnyZodType>
-  | SubscriptionResourceDefinition<AnyZodType, AnyZodType>
+  | QueryResourceDefinition<
+      AnyZodType,
+      AnyZodType,
+      HandlerContext<ResourceInputMap>
+    >
+  | SubscriptionResourceDefinition<
+      AnyZodType,
+      AnyZodType,
+      HandlerContext<ResourceInputMap>
+    >
   | DerivedResourceDefinition<AnyZodType, AnyZodType, any, any>;
 
 export type StreamSession<TClientMessage = unknown> = {
@@ -106,11 +127,12 @@ export type StreamHandlerDefinition<
   TInput extends z.ZodType = z.ZodType,
   TClientMessage extends z.ZodType = z.ZodType,
   TServerMessage extends z.ZodType = z.ZodType,
+  TContext = HandlerContext,
 > = {
   contract: StreamContract<TInput, TClientMessage, TServerMessage>;
   open: (
     input: z.output<TInput>,
-    context: HandlerContext & {
+    context: TContext & {
       emit: (message: z.input<NoInfer<TServerMessage>>) => void;
       fail: (cause: unknown) => void;
     },
@@ -123,10 +145,21 @@ export const defineStreamHandler = <
   TInput extends z.ZodType,
   TClientMessage extends z.ZodType,
   TServerMessage extends z.ZodType,
+  TContext = HandlerContext,
 >(
   contract: StreamContract<TInput, TClientMessage, TServerMessage>,
-  open: StreamHandlerDefinition<TInput, TClientMessage, TServerMessage>["open"],
-): StreamHandlerDefinition<TInput, TClientMessage, TServerMessage> => ({
+  open: StreamHandlerDefinition<
+    TInput,
+    TClientMessage,
+    TServerMessage,
+    TContext
+  >["open"],
+): StreamHandlerDefinition<
+  TInput,
+  TClientMessage,
+  TServerMessage,
+  TContext
+> => ({
   contract,
   open,
 });
@@ -136,6 +169,10 @@ type ResourceContracts = Record<
   ResourceContract<AnyZodType, AnyZodType>
 >;
 
+type ResourceInputs<TContracts extends ResourceContracts> = {
+  [TId in keyof TContracts]: z.input<TContracts[TId]["input"]>;
+};
+
 type DependencyOutputs<
   TContracts extends ResourceContracts,
   TDependencies extends Record<string, unknown>,
@@ -154,17 +191,29 @@ type DependencySource<TDependencies> = {
     : { dependencies?: never };
 };
 
-type QueryFor<TContract extends ResourceContract<AnyZodType, AnyZodType>> = {
+type QueryFor<
+  TContract extends ResourceContract<AnyZodType, AnyZodType>,
+  TContracts extends ResourceContracts,
+> = {
   contract: TContract;
 } & Omit<
-  QueryResourceDefinition<TContract["input"], TContract["output"]>,
+  QueryResourceDefinition<
+    TContract["input"],
+    TContract["output"],
+    HandlerContext<ResourceInputs<NoInfer<TContracts>>>
+  >,
   "contract"
 >;
 
 type SubscriptionFor<
   TContract extends ResourceContract<AnyZodType, AnyZodType>,
+  TContracts extends ResourceContracts,
 > = { contract: TContract } & Omit<
-  SubscriptionResourceDefinition<TContract["input"], TContract["output"]>,
+  SubscriptionResourceDefinition<
+    TContract["input"],
+    TContract["output"],
+    HandlerContext<ResourceInputs<NoInfer<TContracts>>>
+  >,
   "contract"
 >;
 
@@ -186,8 +235,8 @@ type ConfiguredResource<
   TDependencies,
   TId extends keyof TContracts,
 > =
-  | QueryFor<TContracts[TId]>
-  | SubscriptionFor<TContracts[TId]>
+  | QueryFor<TContracts[TId], TContracts>
+  | SubscriptionFor<TContracts[TId], TContracts>
   | (TId extends keyof TDependencies
       ? TDependencies[TId] extends Record<
           string,
@@ -213,26 +262,97 @@ export type AuthDuration = `${number}${"m" | "h" | "d"}`;
 export type AuthConfigDefinition = {
   mode: "cli-login";
   origins?: string[];
-  sessionLifetime?: "never" | AuthDuration;
+  sessionLifetime?: "forever" | AuthDuration;
   trustedProxyPeer?: string;
 };
 
 export type ServerConfigDefinition = {
   host?: string;
-  logFile?: string;
   port?: number;
   productionWebAssetsDir?: string;
   watch?: boolean;
 };
 
-type StreamDefinitions = Readonly<
-  Record<string, StreamHandlerDefinition<AnyZodType, AnyZodType, AnyZodType>>
+type StreamDefinitions<TContext = HandlerContext<ResourceInputMap>> = Readonly<
+  Record<
+    string,
+    StreamHandlerDefinition<AnyZodType, AnyZodType, AnyZodType, TContext>
+  >
 >;
 
 type OperationDefinitions = Readonly<
-  Record<string, OperationDefinition<AnyZodType, AnyZodType>>
+  Record<
+    string,
+    OperationDefinition<
+      AnyZodType,
+      AnyZodType,
+      OperationContext<ResourceInputMap>
+    >
+  >
 >;
 
+type OperationInputs = Record<string, AnyZodType>;
+
+type OperationOutputSchema<
+  TOutputs,
+  TId extends PropertyKey,
+> = TId extends keyof TOutputs
+  ? TOutputs[TId] extends z.ZodType
+    ? TOutputs[TId]
+    : z.ZodVoid
+  : z.ZodVoid;
+
+type ConfiguredOperations<
+  TInputs extends OperationInputs,
+  TOutputs,
+  TContracts extends ResourceContracts,
+> = {
+  [TId in keyof TInputs]: {
+    input: TInputs[TId];
+    output?: OperationOutputSchema<TOutputs, TId>;
+    handle: OperationDefinition<
+      TInputs[TId],
+      OperationOutputSchema<TOutputs, TId>,
+      OperationContext<ResourceInputs<TContracts>>
+    >["handle"];
+  };
+} & {
+  [TId in keyof TOutputs]: TOutputs[TId] extends z.ZodType
+    ? { output: TOutputs[TId] }
+    : { output?: never };
+};
+
+type NormalizedOperations<
+  TInputs extends OperationInputs,
+  TOutputs,
+  TContracts extends ResourceContracts,
+> = {
+  [TId in keyof TInputs]: OperationDefinition<
+    TInputs[TId],
+    OperationOutputSchema<TOutputs, TId>,
+    OperationContext<ResourceInputs<TContracts>>
+  >;
+};
+
+const normalizeOperations = <
+  TInputs extends OperationInputs,
+  TOutputs,
+  TContracts extends ResourceContracts,
+>(
+  operations: ConfiguredOperations<TInputs, TOutputs, TContracts> | undefined,
+): NormalizedOperations<TInputs, TOutputs, TContracts> | undefined => {
+  if (operations === undefined) {
+    return undefined;
+  }
+  // Preserve every key and handler; only absent output schemas become ZodVoid.
+  return Object.fromEntries(
+    Object.entries(operations).map(([id, definition]) => [
+      id,
+      { ...definition, output: definition.output ?? z.void() },
+    ]),
+  ) as NormalizedOperations<TInputs, TOutputs, TContracts>;
+};
+
 export type ConfigDefinition<
   TResources extends Readonly<Record<string, unknown>> = Readonly<
     Record<string, ResourceDefinition>
@@ -278,16 +398,21 @@ export const defineOvermuxServer = <
   const TContracts extends ResourceContracts = {},
   const TDependencies = {},
   const TStreams extends StreamDefinitions = {},
-  const TOperations extends OperationDefinitions = {},
+  const TInputs extends OperationInputs = {},
+  const TOutputs = {},
 >(definition: {
-  operations?: TOperations;
+  operations?: ConfiguredOperations<TInputs, TOutputs, NoInfer<TContracts>>;
   resources: ConfiguredResources<TContracts, TDependencies>;
-  streams?: TStreams;
+  streams?: TStreams &
+    StreamDefinitions<HandlerContext<ResourceInputs<NoInfer<TContracts>>>>;
 }): ConfigDefinition<
   ConfiguredResources<TContracts, TDependencies>,
   TStreams,
-  TOperations
-> => definition;
+  NormalizedOperations<TInputs, TOutputs, TContracts>
+> => ({
+  ...definition,
+  operations: normalizeOperations(definition.operations),
+});
 
 export const defineOvermuxConfig = <const TServer extends ConfigDefinition>(
   definition: OvermuxConfigDefinition<TServer>,

package/src/public/server.ts

@@ -1,16 +1 @@
-export {
-  checkOvermux,
-  type CheckDiagnostic,
-  type CheckOvermuxOptions,
-  type CheckResult,
-} from "../internal/server/check-overmux";
-export {
-  getOvermuxPaths,
-  type GetOvermuxPathsOptions,
-  type OvermuxPaths,
-} from "../internal/server/paths";
-export {
-  startOvermuxServer,
-  type OvermuxServer,
-  type OvermuxServerOptions,
-} from "../internal/server/start-overmux-server";
+export { getOvermuxPaths } from "../internal/server/paths";

package/dist/docs/100-introduction/100-what-is-overmux.md

@@ -1,7 +0,0 @@
----
-title: What is Overmux?
----
-
-Overmux is a web-based, customizable dev environment. Designed for coding using Agents.
-
-

package/dist/docs/300-fundamentals/100-project-structure.md

@@ -1,23 +0,0 @@
----
-title: Project Structure
----
-
-`overmux init` creates this minimal userland application:
-
-```text
-.gitignore
-mise.toml               Mise installations only
-package.json
-pnpm-lock.yaml
-overmux.config.ts       authentication, server, Vite, and production settings
-src/server/index.ts     trusted resources, streams, and operations
-src/ui/app.tsx          browser application definition
-src/ui/index.html       browser document
-src/ui/main.tsx         React and Overmux host entry point
-src/ui/styles.css       application styles
-vite.config.ts          browser development and production build configuration
-```
-
-The server and UI are separate trust boundaries. `src/server/index.ts` runs as trusted Node.js code. Files under `src/ui` run in the browser and communicate with the server through Overmux's public APIs.
-
-The generated application has no shared directory. Add browser-safe shared schemas only when both sides need them.

package/dist/docs/300-fundamentals/200-configuration.md

@@ -1,3 +0,0 @@
----
-title: Configuration
----

package/dist/docs/300-fundamentals/300-theming.md

@@ -1,54 +0,0 @@
----
-title: Theming
----
-
-## Host and platform selectors
-
-Overmux sets two independent attributes on the hosted application's `<html>` element before React mounts:
-
-```html
-<html data-om-host="desktop" data-om-platform="macos">
-```
-
-Use these public CSS selectors to adapt your application to its environment:
-
-```css
-/* Hide browser-only installation guidance in native and installed apps. */
-html:not([data-om-host="browser"]) .install-prompt {
-  display: none;
-}
-
-/* OS-specific styling also works when using Overmux in a browser. */
-html[data-om-platform="macos"] .shortcut-hint {
-  font-family: system-ui;
-}
-
-/* Combine the independent host and platform selectors. */
-html[data-om-host="desktop"][data-om-platform="windows"] .app-toolbar {
-  padding-inline: 1rem;
-}
-```
-
-### Host values
-
-| `data-om-host` | Meaning |
-| --- | --- |
-| `desktop` | Running inside the native Overmux desktop host, regardless of window size. |
-| `browser` | Running in a regular browser tab or window. |
-| `pwa` | Running as an installed web app in `standalone`, `minimal-ui`, or `window-controls-overlay` display mode, including Safari's installed standalone mode. |
-
-A progressive web app (PWA) is a website that can run as an installed application. Visiting an installable website does not make the host `pwa`. Ordinary browser fullscreen does not qualify either. Native desktop detection takes precedence over display mode. Browser/PWA selectors update when the supported display modes change.
-
-`desktop` describes the host, not a desktop-sized layout. Use CSS media or container queries for responsive layout. The native host's implementation technology is not a CSS value.
-
-### Platform values
-
-`data-om-platform` is always one of `macos`, `windows`, `linux`, `android`, `ios`, or `unknown`.
-
-The native desktop host supplies its OS identity through versioned preload metadata. Browsers use best-effort detection from browser-provided platform and user-agent information, including touch-capable iPads presenting a Mac identity. Missing, obscured, or unrecognized information can yield `unknown`; do not use these selectors for security decisions or feature detection.
-
-### Scope
-
-These attributes belong to the hosted application document, independently of `OvermuxThemeScope`. They do not change theme tokens, color scheme, contrast, nested theme scopes, or portal inheritance. Selectors anchored at `html` also match portal content in the same document, including caller-owned external portal containers.
-
-This API does not theme native window controls or the desktop connection screen. It requires no public JavaScript API; use the attributes directly in your application's CSS.

package/dist/docs/300-fundamentals/400-server.md

@@ -1,3 +0,0 @@
----
-title: Server
----

package/dist/docs/300-fundamentals/500-client.md

@@ -1,3 +0,0 @@
----
-title: Client
----

package/dist/docs/300-fundamentals/600-operations.md

@@ -1,3 +0,0 @@
----
-title: Operations
----

package/dist/docs/300-fundamentals/700-resources.md

@@ -1,3 +0,0 @@
----
-title: Resources
----

package/dist/docs/300-fundamentals/800-streams.md

@@ -1,3 +0,0 @@
----
-title: Streams
----

package/dist/docs/300-fundamentals/900-authentication-and-security.md

@@ -1,3 +0,0 @@
----
-title: Authentication and Security
----

package/dist/docs/400-reference/100-configuration.md

@@ -1,23 +0,0 @@
----
-title: Configuration
----
-
-## Instance identity
-
-```ts
-import { defineOvermuxConfig } from "overmux";
-import { server } from "./server";
-
-export default defineOvermuxConfig({
-  server,
-  instanceId: ({ port }) => `rich-work-${port}`,
-});
-```
-
-`instanceId` accepts a fixed string (for example `instanceId: "rich-work"`) or a function of `{ port }`. It is resolved once at server startup using the actual listening port. Every hostname serving this running instance reports the same ID. Changing the port intentionally changes a port-dependent ID.
-
-`port` in `overmux.config.ts` must be an integer from `1` through `65535`. Internal listeners and tests may use `0` to ask the OS for a free port; this is not a user configuration value.
-
-The default is the machine hostname followed by `-<port>`. IDs are canonical lowercase ASCII: 1-253 characters, start and end with a letter or digit, and may contain dots or hyphens internally. Explicit IDs are validated, never silently normalized. Set an explicit ID if the machine hostname does not meet these rules.
-
-Distinct instances require distinct IDs. IDs are names, not credentials; authentication is still required. Deep links use `overmux://<instance-id>/<application-route>`. Their authority is only a lookup key, never a network address. Use the live runtime helpers or `overmux instance --json` to produce a prefix rather than guessing it from a browser URL.

package/dist/docs/400-reference/200-server-api.md

@@ -1,21 +0,0 @@
----
-title: Server API
----
-
-## Instance identity in handlers
-
-Operation, resource, and stream handler contexts expose the running instance:
-
-```ts
-import { defineOperation } from "overmux";
-import { z } from "zod";
-
-export const paneLink = defineOperation({
-  input: z.object({ paneId: z.string() }),
-  output: z.string(),
-  handle: ({ paneId }, context) =>
-    `${context.instance.getDeepLinkPrefix()}/panes/${encodeURIComponent(paneId)}`,
-});
-```
-
-`context.instance.getInstanceId(): string` and `context.instance.getDeepLinkPrefix(): string` are synchronous and ready before handlers execute. They belong to this server runtime, not process-global state. The prefix is exactly `overmux://<instance-id>` without a trailing slash. Encode route segments once, not the whole assembled URL.

package/dist/docs/400-reference/300-client-api.md

@@ -1,39 +0,0 @@
----
-title: Client API
----
-
-## Instance identity
-
-```tsx
-import { createOvermuxHooks } from "overmux/client";
-import type { serverConfig } from "./server";
-
-const { useInstance } = createOvermuxHooks<typeof serverConfig>();
-
-const PaneLink = ({ paneId }: { paneId: string }) => {
-  const instance = useInstance();
-  if (!instance) return null;
-  return <a href={`${instance.deepLinkPrefix}/panes/${encodeURIComponent(paneId)}`}>Open pane in desktop</a>;
-};
-```
-
-Use these hooks under the existing Overmux provider. `useInstance()` returns `{ instanceId, deepLinkPrefix } | undefined` and rerenders when authenticated discovery arrives or changes after reconnecting.
-
-The same scoped `overmuxServerApi` object passed to command handlers for operations also provides `overmuxServerApi.getInstanceId()` and `overmuxServerApi.getDeepLinkPrefix()`. Both return `undefined` until the authenticated server announces its identity. The prefix is exactly `overmux://<instance-id>`, without a trailing slash. Browser addresses are not instance identities. Desktop hosts receive discovery through a narrow identity bridge automatically; application code does not need to forward it.
-
-## Clipboard
-
-```ts
-import { readClipboardText, writeClipboardText } from "overmux/client";
-
-await writeClipboardText("Text to copy");
-const text = await readClipboardText();
-```
-
-`readClipboardText(): Promise<string>` reads the system clipboard through `navigator.clipboard.readText()`. It never reads through the desktop bridge.
-
-`writeClipboardText(text: string): Promise<void>` uses Overmux's version-1 desktop write bridge when present, otherwise `navigator.clipboard.writeText()`. Desktop writes are fire-and-forget: resolution confirms dispatch, not completion or acceptance by the host. Existing host origin and active-frame checks still apply.
-
-Both reject on unavailable browser APIs, browser permission failures, or synchronous desktop dispatch failures. Browser secure-context, focus, permissions, and user-activation restrictions still apply. These APIs target the system clipboard, not the X11 primary selection. Only read clipboard data you need and trust the source of text you write.
-
-For terminal-program access via OSC 52, use the opt-in factories from `@overmux/xterm/client` rather than wiring platform bridges in application code.

package/dist/docs/400-reference/400-cli/400-check.md

@@ -1,20 +0,0 @@
----
-title: "overmux check"
-description: "Validate an Overmux configuration"
----
-
-# `overmux check`
-
-Validate an Overmux configuration.
-
-## Usage
-
-```text
-overmux check [--config path]
-```
-
-## Options
-
-| Flag | Description | Default |
-| --- | --- | --- |
-| `--config <path>, -c <path>` | Configuration file | `$XDG_CONFIG_HOME/overmux/overmux.config.ts` |

package/dist/docs/400-reference/400-cli/500-ai-context.md

@@ -1,102 +0,0 @@
----
-title: "overmux ai context"
-description: "Set up your coding agent and configure its Overmux context"
----
-
-# `overmux ai context`
-
-Print version-aware Overmux guidance for coding agents as Markdown.
-
-## Usage
-
-```text
-overmux ai context [--config path]
-```
-
-## Set up your coding agent
-
-Add a short instruction that tells your agent how to load the context when it needs Overmux guidance:
-
-<CodeBlockTabs defaultValue="agents">
-  <CodeBlockTabsList>
-    <CodeBlockTabsTrigger value="agents">AGENTS.md</CodeBlockTabsTrigger>
-    <CodeBlockTabsTrigger value="claude">CLAUDE.md</CodeBlockTabsTrigger>
-  </CodeBlockTabsList>
-  <CodeBlockTab value="agents">
-
-```bash
-echo 'Run `overmux ai context` for help configuring Overmux.' >> AGENTS.md
-```
-
-  </CodeBlockTab>
-  <CodeBlockTab value="claude">
-
-```bash
-echo 'Run `overmux ai context` for help configuring Overmux.' >> CLAUDE.md
-```
-
-  </CodeBlockTab>
-</CodeBlockTabs>
-
-## Configure context snippets
-
-Set `aiContextSnippets` in `$XDG_CONFIG_HOME/overmux/overmux.config.ts` to choose the guidance included in the command output:
-
-```ts
-import {
-  coreAiContextSnippets,
-  defineOvermuxConfig,
-} from "overmux";
-
-export default defineOvermuxConfig({
-  aiContextSnippets: coreAiContextSnippets,
-  // ...
-});
-```
-
-When `aiContextSnippets` is omitted, Overmux uses `defaultAiContextSnippets`. Set it to an empty array to emit no context.
-
-## Options
-
-| Flag | Description | Default |
-| --- | --- | --- |
-| `--config <path>, -c <path>` | Configuration file | `$XDG_CONFIG_HOME/overmux/overmux.config.ts` |
-
-## Preset groups
-
-| Export | Included snippets |
-| --- | --- |
-| `defaultAiContextSnippets` | `package-source`, `tech-stack-recommendations` |
-| `coreAiContextSnippets` | `package-source` |
-
-## Snippet reference
-
-### `package-source`
-
-Export: `packageSourceSnippet`
-
-Included in the core and default presets. Tells agents to inspect the documentation and TypeScript source shipped in installed Overmux packages so their guidance matches the versions used by the application.
-
-### `tech-stack-recommendations`
-
-Export: `techStackRecommendationsSnippet`
-
-Included in the default preset. Recommends pnpm, TanStack Router, shadcn/ui, and Zod while deferring to the application's established stack.
-
-You can compose an explicit selection from the individual exports:
-
-```ts
-import {
-  defineOvermuxConfig,
-  packageSourceSnippet,
-  techStackRecommendationsSnippet,
-} from "overmux";
-
-export default defineOvermuxConfig({
-  aiContextSnippets: [
-    packageSourceSnippet,
-    techStackRecommendationsSnippet,
-  ],
-  // ...
-});
-```