@guuey/config 0.1.1 → 0.2.0

package/dist/agent.d.ts

@@ -23,7 +23,7 @@
  *
  * Defaults applied by the pod runtime when fields are absent:
  * - `framework`   → `'claude-agent-sdk'`
- * - `mcpServers`  → `{ ggui: { url: 'https://mcp.ggui.ai' } }` (platform default; declaring `mcpServers` REPLACES this — not merged)
+ * - `mcpServers`  → `{ ggui: { url: 'https://mcp.ggui.ai' } }` (platform default; declaring `mcpServers` MERGES ON TOP of this (guuey#24 option A); opt out with `ggui: false`)
  * - `model`       → framework-chosen default (Claude SDK → `claude-sonnet-5`)
  * - `systemPrompt`→ `GUUEY_DEFAULT_SYSTEM_PROMPT` from `./system-prompt`
  * - `auth`        → `'anonymous'`
@@ -49,20 +49,30 @@ import { z } from 'zod';
  */
 export declare const AGENT_FRAMEWORKS: readonly ["claude-agent-sdk", "openai-agents-sdk", "google-adk", "vanilla"];
 export type AgentFramework = (typeof AGENT_FRAMEWORKS)[number];
+/**
+ * Cross-app profile access posture. `'read'` = the agent may recall the
+ * user's cross-app profile; `'read-write'` additionally lets it write this
+ * app's section. Absent = no profile access (default-closed, consent-gated).
+ */
+export declare const ProfileAccessSchema: z.ZodEnum<{
+    read: "read";
+    "read-write": "read-write";
+}>;
+/** Static TypeScript type derived from {@link ProfileAccessSchema}. */
+export type ProfileAccess = z.infer<typeof ProfileAccessSchema>;
 /**
  * A single MCP server entry inside `agent.mcpServers`.
  *
  * Discriminated union on `kind` — one slot per hosting mode:
- * - `colocated` — stdio child inside the agent pod
+ * - `colocated` — guuey-managed HTTP child inside the agent pod
  * - `hosted`    — guuey-hosted registry MCP (Starter+)
  * - `proxied`   — 3rd-party SaaS via mcp-proxy credential broker (v2)
  * - `external`  — builder-hosted, reached by URL (plain or federated)
  */
 declare const McpServerSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"colocated">;
-    command: z.ZodString;
-    args: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    source: z.ZodString;
+    devPort: z.ZodOptional<z.ZodNumber>;
 }, z.core.$strict>, z.ZodObject<{
     kind: z.ZodLiteral<"hosted">;
     server: z.ZodOptional<z.ZodString>;
@@ -81,7 +91,46 @@ declare const McpServerSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     federate: z.ZodOptional<z.ZodBoolean>;
     headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     devPort: z.ZodOptional<z.ZodNumber>;
+    mcpResourceUrl: z.ZodOptional<z.ZodURL>;
+    profileAccess: z.ZodOptional<z.ZodEnum<{
+        read: "read";
+        "read-write": "read-write";
+    }>>;
 }, z.core.$strict>], "kind">;
+/**
+ * One declared `mcpServers` VALUE: a real server entry, or the literal `false`
+ * — the generative-UI opt-out, valid ONLY under the `ggui` key (enforced by
+ * the agent-level refine; the subtree schema stays lenient by design).
+ */
+export declare const McpServerEntrySchema: z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"colocated">;
+    source: z.ZodString;
+    devPort: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"hosted">;
+    server: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+    devPort: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"proxied">;
+    connection: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"external">;
+    url: z.ZodURL;
+    transport: z.ZodOptional<z.ZodEnum<{
+        http: "http";
+        sse: "sse";
+    }>>;
+    federate: z.ZodOptional<z.ZodBoolean>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    devPort: z.ZodOptional<z.ZodNumber>;
+    mcpResourceUrl: z.ZodOptional<z.ZodURL>;
+    profileAccess: z.ZodOptional<z.ZodEnum<{
+        read: "read";
+        "read-write": "read-write";
+    }>>;
+}, z.core.$strict>], "kind">, z.ZodLiteral<false>]>;
+export type DeclaredMcpServers = Record<string, GuueyAgentMcpServer | false>;
 /**
  * Tool-gate block — allowlist applied first (intersect with what the MCP
  * server advertises), then denylist subtracts. Tool names are MCP-namespaced
@@ -150,6 +199,40 @@ declare const DeploySchema: z.ZodObject<{
  * Exported as a zod object so the top-level `GuueyJsonV1` schema (in
  * `./schema.ts`) can nest it. Static type via {@link GuueyAgent}.
  */
+/**
+ * The `agent.mcpServers` map alone — for consumers that resolve/lower the
+ * servers SUBTREE without validating the whole snapshot (deploy-controller's
+ * resolve-mcp): whole-snapshot strictness made lowering fail open on any
+ * schema field the running consumer predates.
+ */
+export declare const McpServersSection: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"colocated">;
+    source: z.ZodString;
+    devPort: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"hosted">;
+    server: z.ZodOptional<z.ZodString>;
+    source: z.ZodOptional<z.ZodString>;
+    devPort: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"proxied">;
+    connection: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"external">;
+    url: z.ZodURL;
+    transport: z.ZodOptional<z.ZodEnum<{
+        http: "http";
+        sse: "sse";
+    }>>;
+    federate: z.ZodOptional<z.ZodBoolean>;
+    headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    devPort: z.ZodOptional<z.ZodNumber>;
+    mcpResourceUrl: z.ZodOptional<z.ZodURL>;
+    profileAccess: z.ZodOptional<z.ZodEnum<{
+        read: "read";
+        "read-write": "read-write";
+    }>>;
+}, z.core.$strict>], "kind">, z.ZodLiteral<false>]>>;
 export declare const AgentSectionV1: z.ZodObject<{
     mode: z.ZodOptional<z.ZodEnum<{
         code: "code";
@@ -161,6 +244,7 @@ export declare const AgentSectionV1: z.ZodObject<{
         "google-adk": "google-adk";
         vanilla: "vanilla";
     }>>;
+    entry: z.ZodOptional<z.ZodString>;
     model: z.ZodOptional<z.ZodString>;
     modelProvider: z.ZodOptional<z.ZodEnum<{
         openai: "openai";
@@ -169,11 +253,10 @@ export declare const AgentSectionV1: z.ZodObject<{
     systemPrompt: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
         file: z.ZodString;
     }, z.core.$strict>]>>;
-    mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
         kind: z.ZodLiteral<"colocated">;
-        command: z.ZodString;
-        args: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        source: z.ZodString;
+        devPort: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>, z.ZodObject<{
         kind: z.ZodLiteral<"hosted">;
         server: z.ZodOptional<z.ZodString>;
@@ -192,7 +275,12 @@ export declare const AgentSectionV1: z.ZodObject<{
         federate: z.ZodOptional<z.ZodBoolean>;
         headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         devPort: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strict>], "kind">>>;
+        mcpResourceUrl: z.ZodOptional<z.ZodURL>;
+        profileAccess: z.ZodOptional<z.ZodEnum<{
+            read: "read";
+            "read-write": "read-write";
+        }>>;
+    }, z.core.$strict>], "kind">, z.ZodLiteral<false>]>>>;
     tools: z.ZodOptional<z.ZodObject<{
         allowlist: z.ZodOptional<z.ZodArray<z.ZodString>>;
         denylist: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -223,6 +311,10 @@ export declare const AgentSectionV1: z.ZodObject<{
         user: "user";
         app: "app";
     }>>>;
+    profileAccess: z.ZodOptional<z.ZodEnum<{
+        read: "read";
+        "read-write": "read-write";
+    }>>;
     env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
     secrets: z.ZodOptional<z.ZodArray<z.ZodString>>;
     endpoint: z.ZodOptional<z.ZodObject<{
@@ -271,14 +363,68 @@ export type GuueyAgentDeploy = z.infer<typeof DeploySchema>;
  */
 export declare function validateNoLiteralSecrets(agent: GuueyAgent | undefined): string[];
 /**
- * Platform default MCP server map. Applied by the pod when `agent.mcpServers`
- * is absent. Exposed here so non-pod consumers (CLI dry-run, lints) can show
- * the effective shape without duplicating the literal.
+ * Validate that every `kind: 'colocated'` entry's NAME (the `mcpServers`
+ * map key) is safe to compose into `colocatedResourceUrl` — i.e. passes
+ * {@link isValidColocatedServerName} (from `./colocated.ts`, the single
+ * source of truth for the rule). Returns a list of human-readable
+ * violation messages (empty = clean).
+ */
+export declare function validateColocatedServerNames(agent: GuueyAgent | undefined): string[];
+/**
+ * Validate that no `agent.mcpServers` entry uses `kind: 'proxied'`. Returns a
+ * list of human-readable violation messages (empty = clean), one per proxied
+ * entry, naming the server so the builder knows which ref to change.
+ */
+export declare function validateNoProxiedServers(agent: GuueyAgent | undefined): string[];
+/**
+ * The reserved colocated key the auto-injected memory MCP is booted + spliced
+ * under (memmcp). NEVER builder-declarable — the memory child's own server
+ * advertises this same name and its aud is `colocatedResourceUrl(appId, this)`.
+ */
+export declare const RESERVED_MEMORY_SERVER_NAME = "guuey-memory";
+/**
+ * The reserved colocated key the auto-injected cross-app profile MCP is
+ * booted + spliced under (profile T1+). NEVER builder-declarable — mirrors
+ * {@link RESERVED_MEMORY_SERVER_NAME}'s reservation for the same reason: a
+ * builder-declared server under this key would be silently replaced by the
+ * platform entry at invoke time.
+ */
+export declare const RESERVED_PROFILE_SERVER_NAME = "guuey-profile";
+/**
+ * Every `mcpServers` map key the platform reserves. Extensible — one entry
+ * today ({@link RESERVED_MEMORY_SERVER_NAME}); future platform-injected
+ * servers add their key here and inherit the deploy-time rejection for free.
+ */
+export declare const RESERVED_MCP_SERVER_NAMES: readonly string[];
+/**
+ * Validate that no `agent.mcpServers` entry uses a platform-RESERVED name
+ * ({@link RESERVED_MCP_SERVER_NAMES}) — regardless of `kind` (the key is
+ * reserved, not just one hosting mode; a builder must not shadow it as
+ * `colocated`, `external`, or anything else). Returns a list of human-readable
+ * violation messages (empty = clean), one per reserved entry. Mirrors
+ * {@link validateNoProxiedServers}'s shape.
+ */
+export declare function validateReservedServerNames(agent: GuueyAgent | undefined): string[];
+/**
+ * Platform default MCP server map. Seeded under every declared map by
+ * {@link effectiveMcpServers} (opt out with `ggui: false`). Exposed here so
+ * non-pod consumers (CLI dry-run, lints) can show the effective shape without
+ * duplicating the literal.
  *
  * The ggui server is `kind: 'external'` — it is builder-declared when present
  * or injected by the platform at runtime. Federation still detects it by host
  * (via `isGguiUrl`) regardless of which key it's declared under.
  */
 export declare const DEFAULT_AGENT_MCP_SERVERS: Record<string, GuueyAgentMcpServer>;
+/**
+ * The EFFECTIVE server map (guuey#24, option A): seed the platform default,
+ * layer the declared map on top (explicit wins), drop `ggui: false`. This is
+ * the ONE owner of default-application semantics — the resolution seams
+ * (credential broker, render-tool resolution) call this; declared-map
+ * ITERATION sites use {@link declaredServerEntries} instead.
+ */
+export declare function effectiveMcpServers(declared: DeclaredMcpServers | undefined): Record<string, GuueyAgentMcpServer>;
+/** The declared entries that are real servers (the `ggui: false` opt-out filtered out) — the narrowing every declared-map iteration site uses. */
+export declare function declaredServerEntries(servers: DeclaredMcpServers | undefined): Array<[string, GuueyAgentMcpServer]>;
 export {};
 //# sourceMappingURL=agent.d.ts.map

package/dist/agent.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,6EAKnB,CAAC;AACX,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AAoF/D;;;;;;;;GAQG;AACH,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;4BAKnB,CAAC;AAEH;;;;GAIG;AACH,QAAA,MAAM,eAAe;;;kBAGnB,CAAC;AAEH;;;;;;;;GAQG;AACH,QAAA,MAAM,mBAAmB;;;kBAGvB,CAAC;AAcH;;;;GAIG;AACH,QAAA,MAAM,kBAAkB;;oBAGtB,CAAC;AAEH;;;;;;GAMG;AACH,QAAA,MAAM,oBAAoB;;;kBAGxB,CAAC;AAEH;;;;;;;;;;GAUG;AACH,QAAA,MAAM,YAAY;;;;;;;;;kBAKhB,CAAC;AAsBH;;;;;GAKG;AACH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAoEzB,CAAC;AAEH,kEAAkE;AAClE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAExD,oCAAoC;AACpC,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAElE,4BAA4B;AAC5B,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAElE,iCAAiC;AACjC,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEpE,kDAAkD;AAClD,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAExE,4BAA4B;AAC5B,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAEtE,0BAA0B;AAC1B,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAuE5D;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,UAAU,GAAG,SAAS,GAC5B,MAAM,EAAE,CAiCV;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAEzE,CAAC"}
+{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../src/agent.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB;;;;;;GAMG;AACH,eAAO,MAAM,gBAAgB,6EAKnB,CAAC;AACX,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,gBAAgB,CAAC,CAAC,MAAM,CAAC,CAAC;AAS/D;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;;EAAiC,CAAC;AAClE,uEAAuE;AACvE,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AA0FhE;;;;;;;;GAQG;AACH,QAAA,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;4BAKnB,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;mDAA+C,CAAC;AACjF,MAAM,MAAM,kBAAkB,GAAG,MAAM,CAAC,MAAM,EAAE,mBAAmB,GAAG,KAAK,CAAC,CAAC;AAE7E;;;;GAIG;AACH,QAAA,MAAM,eAAe;;;kBAGnB,CAAC;AAEH;;;;;;;;GAQG;AACH,QAAA,MAAM,mBAAmB;;;kBAGvB,CAAC;AAcH;;;;GAIG;AACH,QAAA,MAAM,kBAAkB;;oBAGtB,CAAC;AAEH;;;;;;GAMG;AACH,QAAA,MAAM,oBAAoB;;;kBAGxB,CAAC;AAEH;;;;;;;;;;GAUG;AACH,QAAA,MAAM,YAAY;;;;;;;;;kBAKhB,CAAC;AAsBH;;;;;GAKG;AACH;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;oDAAoD,CAAC;AAEnF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBA4FzB,CAAC;AAEH,kEAAkE;AAClE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AAExD,oCAAoC;AACpC,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAElE,4BAA4B;AAC5B,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AAElE,iCAAiC;AACjC,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEpE,kDAAkD;AAClD,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAExE,4BAA4B;AAC5B,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAEtE,0BAA0B;AAC1B,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAuE5D;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,UAAU,GAAG,SAAS,GAC5B,MAAM,EAAE,CAiCV;AAeD;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,UAAU,GAAG,SAAS,GAC5B,MAAM,EAAE,CAaV;AAaD;;;;GAIG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,UAAU,GAAG,SAAS,GAC5B,MAAM,EAAE,CAaV;AAgBD;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,iBAAiB,CAAC;AAE1D;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,kBAAkB,CAAC;AAE5D;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,EAAE,SAAS,MAAM,EAGtD,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,UAAU,GAAG,SAAS,GAC5B,MAAM,EAAE,CAaV;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAEzE,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,kBAAkB,GAAG,SAAS,GACvC,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAOrC;AAED,kJAAkJ;AAClJ,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,kBAAkB,GAAG,SAAS,GACtC,KAAK,CAAC,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC,CAItC"}

package/dist/agent.js

@@ -23,7 +23,7 @@
  *
  * Defaults applied by the pod runtime when fields are absent:
  * - `framework`   → `'claude-agent-sdk'`
- * - `mcpServers`  → `{ ggui: { url: 'https://mcp.ggui.ai' } }` (platform default; declaring `mcpServers` REPLACES this — not merged)
+ * - `mcpServers`  → `{ ggui: { url: 'https://mcp.ggui.ai' } }` (platform default; declaring `mcpServers` MERGES ON TOP of this (guuey#24 option A); opt out with `ggui: false`)
  * - `model`       → framework-chosen default (Claude SDK → `claude-sonnet-5`)
  * - `systemPrompt`→ `GUUEY_DEFAULT_SYSTEM_PROMPT` from `./system-prompt`
  * - `auth`        → `'anonymous'`
@@ -41,6 +41,7 @@
  */
 import { z } from 'zod';
 import { AGENT_SIZES } from './hosting.js';
+import { isValidColocatedServerName } from './colocated.js';
 /**
  * Supported framework adapters. The pod runtime selects the matching
  * `@guuey/framework-*` adapter at boot. `vanilla` skips the framework
@@ -61,18 +62,25 @@ export const AGENT_FRAMEWORKS = [
  */
 const HeadersSchema = z.record(z.string().min(1), z.string());
 /**
- * `kind: 'colocated'` — MCP server runs as a stdio child **inside the agent
- * pod** (co-locate = same gVisor sandbox). COGS: ~$0 (rides the agent pod).
- * Nocode runtime spawns `command [args…]` at boot.
+ * Cross-app profile access posture. `'read'` = the agent may recall the
+ * user's cross-app profile; `'read-write'` additionally lets it write this
+ * app's section. Absent = no profile access (default-closed, consent-gated).
+ */
+export const ProfileAccessSchema = z.enum(['read', 'read-write']);
+/**
+ * `kind: 'colocated'` — MCP server runs as a guuey-managed HTTP child
+ * **inside the agent pod** (co-locate = same gVisor sandbox). COGS: ~$0
+ * (rides the agent pod). `source` is a project-relative path the Router
+ * lowering builds/boots as a local HTTP server; `devPort` mirrors the
+ * `hosted`/`external` dev-loop story (name→localhost URL resolution for
+ * `guuey dev`).
  */
 const ColocatedMcp = z.strictObject({
     kind: z.literal('colocated'),
-    /** Executable name or path. Required. */
-    command: z.string().min(1),
-    /** Argv beyond `command`. */
-    args: z.array(z.string()).optional(),
-    /** Static headers (less common for stdio, but supported for symmetry). */
-    headers: HeadersSchema.optional(),
+    /** Source directory relative to `guuey.json`. Required. */
+    source: z.string().min(1),
+    /** Local dev-loop port (`guuey dev`) this MCP is served on for name→localhost URL resolution. */
+    devPort: z.number().int().min(1).max(65535).optional(),
 });
 /**
  * `kind: 'hosted'` — a workspace-owned registry MCP running on guuey's
@@ -104,7 +112,7 @@ const HostedMcp = z
  */
 const ProxiedMcp = z.strictObject({
     kind: z.literal('proxied'),
-    /** mcp-proxy connection id (from `guuey connections add`). */
+    /** mcp-proxy connection id (not yet available — rides with the mcp-proxy credential broker). */
     connection: z.string().min(1),
 });
 /**
@@ -130,12 +138,24 @@ const ExternalMcp = z.strictObject({
     headers: HeadersSchema.optional(),
     /** Local dev-loop port (`guuey dev`) this MCP is served on for name→localhost URL resolution. */
     devPort: z.number().int().min(1).max(65535).optional(),
+    /**
+     * INTERNAL — set only by Router lowering; when present the federation mint
+     * uses this as the RFC 8707 resource instead of `url`.
+     */
+    mcpResourceUrl: z.url().optional(),
+    /**
+     * INTERNAL — set only by Router lowering when this entry is the spliced
+     * profile MCP; carries the agent's `profileAccess` posture onto the entry
+     * itself so the profile child's tool gate (read vs read-write) survives
+     * independent of the top-level `agent.profileAccess` field.
+     */
+    profileAccess: ProfileAccessSchema.optional(),
 });
 /**
  * A single MCP server entry inside `agent.mcpServers`.
  *
  * Discriminated union on `kind` — one slot per hosting mode:
- * - `colocated` — stdio child inside the agent pod
+ * - `colocated` — guuey-managed HTTP child inside the agent pod
  * - `hosted`    — guuey-hosted registry MCP (Starter+)
  * - `proxied`   — 3rd-party SaaS via mcp-proxy credential broker (v2)
  * - `external`  — builder-hosted, reached by URL (plain or federated)
@@ -146,6 +166,12 @@ const McpServerSchema = z.discriminatedUnion('kind', [
     ProxiedMcp,
     ExternalMcp,
 ]);
+/**
+ * One declared `mcpServers` VALUE: a real server entry, or the literal `false`
+ * — the generative-UI opt-out, valid ONLY under the `ggui` key (enforced by
+ * the agent-level refine; the subtree schema stays lenient by design).
+ */
+export const McpServerEntrySchema = z.union([McpServerSchema, z.literal(false)]);
 /**
  * Tool-gate block — allowlist applied first (intersect with what the MCP
  * server advertises), then denylist subtracts. Tool names are MCP-namespaced
@@ -238,6 +264,13 @@ const StorageScopeSchema = z.array(z.enum(['user', 'app']));
  * Exported as a zod object so the top-level `GuueyJsonV1` schema (in
  * `./schema.ts`) can nest it. Static type via {@link GuueyAgent}.
  */
+/**
+ * The `agent.mcpServers` map alone — for consumers that resolve/lower the
+ * servers SUBTREE without validating the whole snapshot (deploy-controller's
+ * resolve-mcp): whole-snapshot strictness made lowering fail open on any
+ * schema field the running consumer predates.
+ */
+export const McpServersSection = z.record(z.string().min(1), McpServerEntrySchema);
 export const AgentSectionV1 = z.strictObject({
     // ── Deploy routing ──
     /**
@@ -256,6 +289,14 @@ export const AgentSectionV1 = z.strictObject({
     mode: z.enum(['code', 'declarative']).optional(),
     // ── Framework + runtime ──
     framework: z.enum(AGENT_FRAMEWORKS).optional(),
+    /**
+     * Graceful code-mode: a module (path relative to the project root, built
+     * output) whose default export is the framework-native agent object or a
+     * factory `(guuey: GuueyContext) => agent`. The platform host imports and
+     * runs it — the dev writes zero harness code. Mutually exclusive with the
+     * full-worker `worker` field (which wins when both are present).
+     */
+    entry: z.string().min(1).optional(),
     model: z.string().min(1).optional(),
     /**
      * Managed-LLM provider selector — only meaningful for
@@ -268,18 +309,33 @@ export const AgentSectionV1 = z.strictObject({
     modelProvider: z.enum(['openai', 'openrouter']).optional(),
     systemPrompt: SystemPromptSchema.optional(),
     /**
-     * MCP servers the agent may call. **Replaces** the platform default
-     * (`{ ggui: { kind: 'external', url: 'https://mcp.ggui.ai', transport: 'http' } }`)
-     * when present — not merged. Omit the block to inherit the default; include
-     * `ggui` explicitly to keep it alongside other servers.
+     * MCP servers the agent may call. **Merges on top of** the platform default
+     * (`{ ggui: { kind: 'external', url: 'https://mcp.ggui.ai', transport: 'http' } }`,
+     * guuey#24 option A) — see {@link effectiveMcpServers}. Omit the block to
+     * inherit the default unchanged; declare `ggui` explicitly to override it;
+     * declare `ggui: false` to opt out of it entirely.
      *
-     * Each entry is a discriminated union on `kind`:
-     * - `'colocated'` — stdio child inside the agent pod
+     * Each entry is a discriminated union on `kind`, or the literal `false`
+     * (valid only under the `ggui` key):
+     * - `'colocated'` — guuey-managed HTTP child inside the agent pod
      * - `'hosted'`    — guuey-hosted registry MCP (Starter+)
      * - `'proxied'`   — 3rd-party SaaS via mcp-proxy (v2)
      * - `'external'`  — builder-hosted URL (plain or federated)
      */
-    mcpServers: z.record(z.string().min(1), McpServerSchema).optional(),
+    mcpServers: z
+        .record(z.string().min(1), McpServerEntrySchema)
+        .superRefine((servers, ctx) => {
+        for (const [name, entry] of Object.entries(servers)) {
+            if (entry === false && name !== 'ggui') {
+                ctx.addIssue({
+                    code: z.ZodIssueCode.custom,
+                    path: [name],
+                    message: `mcpServers.${name}: false is only valid for the "ggui" key (it opts out of the platform-default generative-UI server) — remove the "${name}" entry instead`,
+                });
+            }
+        }
+    })
+        .optional(),
     tools: ToolGatesSchema.optional(),
     runtime: RuntimeConfigSchema.optional(),
     /** Claude Agent SDK-specific knobs. Only read when `framework: 'claude-agent-sdk'`. */
@@ -288,6 +344,7 @@ export const AgentSectionV1 = z.strictObject({
     auth: AuthSchema.optional(),
     memory: MemorySchema.optional(),
     storage: StorageScopeSchema.optional(),
+    profileAccess: ProfileAccessSchema.optional(),
     // ── Env + secrets ──
     /** Literal non-sensitive env vars baked into the pod at boot. */
     env: z.record(z.string().min(1), z.string()).optional(),
@@ -388,8 +445,8 @@ export function validateNoLiteralSecrets(agent) {
     const servers = agent?.mcpServers;
     if (!servers)
         return violations;
-    for (const [serverName, server] of Object.entries(servers)) {
-        // Only `colocated` and `external` union arms carry a `headers` field.
+    for (const [serverName, server] of declaredServerEntries(servers)) {
+        // Only the `external` union arm carries a `headers` field.
         const headers = 'headers' in server ? server.headers : undefined;
         if (!headers)
             continue;
@@ -412,10 +469,125 @@ export function validateNoLiteralSecrets(agent) {
     }
     return violations;
 }
+// ── No-invalid-colocated-names validation (deploy-time contract enforcement) ──
+//
+// `agent.mcpServers`' key is schema-typed only `z.string().min(1)` — any
+// non-empty string parses. But at pod boot, `lowerColocated` composes the
+// KEY (not just `source`) into `colocatedResourceUrl(appId, name)`, which
+// THROWS for anything outside `/^[A-Za-z0-9_-]+$/` (see `./colocated.ts`).
+// An invalid colocated name therefore parses fine client-side and only
+// fails once the pod is already booting, as an unactionable
+// `POD_FATAL_BOOT_ERROR` crash-loop. `validateColocatedServerNames` is the
+// deploy-time pre-flight that catches it first — mirrors
+// `validateNoLiteralSecrets`'s shape (explicit lint, called by
+// `@guuey/cli`'s `commands/deploy.ts` right before upload).
+/**
+ * Validate that every `kind: 'colocated'` entry's NAME (the `mcpServers`
+ * map key) is safe to compose into `colocatedResourceUrl` — i.e. passes
+ * {@link isValidColocatedServerName} (from `./colocated.ts`, the single
+ * source of truth for the rule). Returns a list of human-readable
+ * violation messages (empty = clean).
+ */
+export function validateColocatedServerNames(agent) {
+    const violations = [];
+    const servers = agent?.mcpServers;
+    if (!servers)
+        return violations;
+    for (const [name, server] of declaredServerEntries(servers)) {
+        if (server.kind === 'colocated' && !isValidColocatedServerName(name)) {
+            violations.push(`colocated MCP server name "${name}" is invalid — use only letters, digits, hyphen, underscore (it becomes part of a URL and a storage scope)`);
+        }
+    }
+    return violations;
+}
+// ── No-proxied-servers validation (deploy-time contract enforcement) ────────
+//
+// `kind: 'proxied'` keeps its schema arm (the documented mcp-proxy
+// credential-broker deferral — wires when the 2nd stored-creds customer signs
+// up) but has NO runtime support today: a pod that booted one would silently
+// miss those tools. `validateNoProxiedServers` is the synchronous deploy-time
+// pre-flight (mirrors `validateColocatedServerNames`'s shape) that rejects it
+// with a fast, actionable error. The deploy-controller's
+// `resolveMcpServersInSnapshot` carries the authoritative backstop throw for
+// code deploys, which never pass through this validator.
+/**
+ * Validate that no `agent.mcpServers` entry uses `kind: 'proxied'`. Returns a
+ * list of human-readable violation messages (empty = clean), one per proxied
+ * entry, naming the server so the builder knows which ref to change.
+ */
+export function validateNoProxiedServers(agent) {
+    const violations = [];
+    const servers = agent?.mcpServers;
+    if (!servers)
+        return violations;
+    for (const [name, server] of declaredServerEntries(servers)) {
+        if (server.kind === 'proxied') {
+            violations.push(`MCP server "${name}": kind 'proxied' (the mcp-proxy credential broker) is not yet supported — use 'external', 'hosted', or 'colocated'.`);
+        }
+    }
+    return violations;
+}
+// ── Reserved platform MCP server names (deploy-time reservation) ────────────
+//
+// Some `mcpServers` map keys are OWNED by the platform: the runtime splices a
+// platform-managed entry under them (memmcp — the auto-injected memory MCP is
+// spliced under `guuey-memory` for authenticated invokes; see
+// `nocode-runtime/src/run-seam.ts` + `boot-colocated.ts`). A builder that
+// declares a server under a reserved key would (a) boot as builder code under
+// the same key the platform child owns, and (b) be silently REPLACED by the
+// platform entry at invoke time. `validateReservedServerNames` is the
+// synchronous deploy-time pre-flight that rejects it with a fast, actionable
+// 400 — the primary guard; the run-seam collision guard is defense-in-depth for
+// stale pre-validator snapshots. Single source of the reserved literal: this
+// module. The boot/splice layer (`boot-colocated.ts`) imports it from here.
+/**
+ * The reserved colocated key the auto-injected memory MCP is booted + spliced
+ * under (memmcp). NEVER builder-declarable — the memory child's own server
+ * advertises this same name and its aud is `colocatedResourceUrl(appId, this)`.
+ */
+export const RESERVED_MEMORY_SERVER_NAME = 'guuey-memory';
+/**
+ * The reserved colocated key the auto-injected cross-app profile MCP is
+ * booted + spliced under (profile T1+). NEVER builder-declarable — mirrors
+ * {@link RESERVED_MEMORY_SERVER_NAME}'s reservation for the same reason: a
+ * builder-declared server under this key would be silently replaced by the
+ * platform entry at invoke time.
+ */
+export const RESERVED_PROFILE_SERVER_NAME = 'guuey-profile';
+/**
+ * Every `mcpServers` map key the platform reserves. Extensible — one entry
+ * today ({@link RESERVED_MEMORY_SERVER_NAME}); future platform-injected
+ * servers add their key here and inherit the deploy-time rejection for free.
+ */
+export const RESERVED_MCP_SERVER_NAMES = [
+    RESERVED_MEMORY_SERVER_NAME,
+    RESERVED_PROFILE_SERVER_NAME,
+];
 /**
- * Platform default MCP server map. Applied by the pod when `agent.mcpServers`
- * is absent. Exposed here so non-pod consumers (CLI dry-run, lints) can show
- * the effective shape without duplicating the literal.
+ * Validate that no `agent.mcpServers` entry uses a platform-RESERVED name
+ * ({@link RESERVED_MCP_SERVER_NAMES}) — regardless of `kind` (the key is
+ * reserved, not just one hosting mode; a builder must not shadow it as
+ * `colocated`, `external`, or anything else). Returns a list of human-readable
+ * violation messages (empty = clean), one per reserved entry. Mirrors
+ * {@link validateNoProxiedServers}'s shape.
+ */
+export function validateReservedServerNames(agent) {
+    const violations = [];
+    const servers = agent?.mcpServers;
+    if (!servers)
+        return violations;
+    for (const name of Object.keys(servers)) {
+        if (RESERVED_MCP_SERVER_NAMES.includes(name)) {
+            violations.push(`MCP server "${name}": that name is reserved by the platform (an auto-injected server uses it) — rename this server.`);
+        }
+    }
+    return violations;
+}
+/**
+ * Platform default MCP server map. Seeded under every declared map by
+ * {@link effectiveMcpServers} (opt out with `ggui: false`). Exposed here so
+ * non-pod consumers (CLI dry-run, lints) can show the effective shape without
+ * duplicating the literal.
  *
  * The ggui server is `kind: 'external'` — it is builder-declared when present
  * or injected by the platform at runtime. Federation still detects it by host
@@ -424,3 +596,23 @@ export function validateNoLiteralSecrets(agent) {
 export const DEFAULT_AGENT_MCP_SERVERS = {
     ggui: { kind: 'external', url: 'https://mcp.ggui.ai', transport: 'http' },
 };
+/**
+ * The EFFECTIVE server map (guuey#24, option A): seed the platform default,
+ * layer the declared map on top (explicit wins), drop `ggui: false`. This is
+ * the ONE owner of default-application semantics — the resolution seams
+ * (credential broker, render-tool resolution) call this; declared-map
+ * ITERATION sites use {@link declaredServerEntries} instead.
+ */
+export function effectiveMcpServers(declared) {
+    const merged = { ...DEFAULT_AGENT_MCP_SERVERS, ...declared };
+    const out = {};
+    for (const [name, entry] of Object.entries(merged)) {
+        if (entry !== false)
+            out[name] = entry;
+    }
+    return out;
+}
+/** The declared entries that are real servers (the `ggui: false` opt-out filtered out) — the narrowing every declared-map iteration site uses. */
+export function declaredServerEntries(servers) {
+    return Object.entries(servers ?? {}).filter((e) => e[1] !== false);
+}

package/dist/browser.d.ts

@@ -0,0 +1,21 @@
+/**
+ * `@guuey/config/browser` — the package minus `loader.js`.
+ *
+ * `loader.js` imports `node:fs` (guuey.json file resolution), which a
+ * browser bundler cannot chunk — importing the root barrel from client
+ * code fails `next build` outright (Turbopack: "does not support
+ * external modules (request: node:fs)"). Browser consumers (Guuey
+ * Studio's agent-config) import this entry instead; Node consumers
+ * (CLI, backend, pods) keep the root barrel.
+ *
+ * Every module re-exported here must stay free of Node builtins.
+ */
+export * from './schema.js';
+export * from './agent.js';
+export * from './app.js';
+export * from './ggui.js';
+export * from './hosting.js';
+export * from './system-prompt.js';
+export * from './registry.js';
+export * from './guuey-context.js';
+//# sourceMappingURL=browser.d.ts.map

package/dist/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../src/browser.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,cAAc,CAAC;AAC7B,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC"}

package/dist/browser.js

@@ -0,0 +1,20 @@
+/**
+ * `@guuey/config/browser` — the package minus `loader.js`.
+ *
+ * `loader.js` imports `node:fs` (guuey.json file resolution), which a
+ * browser bundler cannot chunk — importing the root barrel from client
+ * code fails `next build` outright (Turbopack: "does not support
+ * external modules (request: node:fs)"). Browser consumers (Guuey
+ * Studio's agent-config) import this entry instead; Node consumers
+ * (CLI, backend, pods) keep the root barrel.
+ *
+ * Every module re-exported here must stay free of Node builtins.
+ */
+export * from './schema.js';
+export * from './agent.js';
+export * from './app.js';
+export * from './ggui.js';
+export * from './hosting.js';
+export * from './system-prompt.js';
+export * from './registry.js';
+export * from './guuey-context.js';

package/dist/colocated.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Synthetic resource-URL helper for `kind: 'colocated'` MCP servers.
+ *
+ * A colocated MCP has no real network URL (it's a guuey-managed HTTP child
+ * inside the agent pod, reached over a loopback/localhost hop the Router
+ * wires up) — but RFC 8707 federation still needs a stable `aud`/resource
+ * value to mint against, and `@guuey/state`'s KV needs a stable scope key.
+ * `colocatedResourceUrl` composes both from `(appId, serverName)`.
+ *
+ * The returned URL is consumed by `backend/amplify/functions/oidcMint/
+ * handler.ts`'s `parseMcpResourceUrl`, which requires: `https://` prefix,
+ * a trailing `/`, and a total length ≤ 512 chars. Both segments are
+ * validated against `/^[A-Za-z0-9_-]+$/` BEFORE composing the URL — they
+ * are used verbatim as URL path segments AND as a KV scope key, so an
+ * unvalidated segment (e.g. containing `/` or whitespace) could smuggle an
+ * extra path segment or break the scope contract.
+ */
+/**
+ * The synthetic origin every colocated resource URL lives on. Guuey-owned
+ * and compile-time-fixed (NOT env-varying — the host never resolves; it
+ * exists only as a stable RFC 8707 `aud` / KV-scope namespace), so
+ * consumers that must recognize "is this URL guuey-controlled?" (e.g. the
+ * stateApi admin-ownership walk's origin filter) import THIS constant
+ * instead of re-declaring the string or threading a new env var.
+ */
+export declare const COLOCATED_ORIGIN = "https://colocated.guuey.com";
+/**
+ * Whether `value` is safe to use as a `colocatedResourceUrl` path segment /
+ * KV scope key (letters, digits, hyphen, underscore only). Single source of
+ * truth for that rule — reused by {@link assertSafeSegment} here AND by
+ * `./agent.ts#validateColocatedServerNames` (the CLI deploy-time check
+ * `@guuey/cli`'s `commands/deploy.ts` runs before upload), so a bad
+ * colocated server name is rejected before deploy instead of surfacing only
+ * as a `POD_FATAL_BOOT_ERROR` crash-loop when the pod's `lowerColocated`
+ * calls `colocatedResourceUrl` at boot.
+ */
+export declare function isValidColocatedServerName(value: string): boolean;
+/**
+ * Build the synthetic `https://colocated.guuey.com/<appId>/<serverName>/`
+ * resource URL for a colocated MCP server. Throws if either segment fails
+ * the safe-segment check.
+ */
+export declare function colocatedResourceUrl(appId: string, serverName: string): string;
+//# sourceMappingURL=colocated.d.ts.map

package/dist/colocated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colocated.d.ts","sourceRoot":"","sources":["../src/colocated.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,gCAAgC,CAAC;AAE9D;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAEjE;AAUD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAI9E"}

package/dist/colocated.js

@@ -0,0 +1,55 @@
+/**
+ * Synthetic resource-URL helper for `kind: 'colocated'` MCP servers.
+ *
+ * A colocated MCP has no real network URL (it's a guuey-managed HTTP child
+ * inside the agent pod, reached over a loopback/localhost hop the Router
+ * wires up) — but RFC 8707 federation still needs a stable `aud`/resource
+ * value to mint against, and `@guuey/state`'s KV needs a stable scope key.
+ * `colocatedResourceUrl` composes both from `(appId, serverName)`.
+ *
+ * The returned URL is consumed by `backend/amplify/functions/oidcMint/
+ * handler.ts`'s `parseMcpResourceUrl`, which requires: `https://` prefix,
+ * a trailing `/`, and a total length ≤ 512 chars. Both segments are
+ * validated against `/^[A-Za-z0-9_-]+$/` BEFORE composing the URL — they
+ * are used verbatim as URL path segments AND as a KV scope key, so an
+ * unvalidated segment (e.g. containing `/` or whitespace) could smuggle an
+ * extra path segment or break the scope contract.
+ */
+const SAFE_SEGMENT_RE = /^[A-Za-z0-9_-]+$/;
+/**
+ * The synthetic origin every colocated resource URL lives on. Guuey-owned
+ * and compile-time-fixed (NOT env-varying — the host never resolves; it
+ * exists only as a stable RFC 8707 `aud` / KV-scope namespace), so
+ * consumers that must recognize "is this URL guuey-controlled?" (e.g. the
+ * stateApi admin-ownership walk's origin filter) import THIS constant
+ * instead of re-declaring the string or threading a new env var.
+ */
+export const COLOCATED_ORIGIN = 'https://colocated.guuey.com';
+/**
+ * Whether `value` is safe to use as a `colocatedResourceUrl` path segment /
+ * KV scope key (letters, digits, hyphen, underscore only). Single source of
+ * truth for that rule — reused by {@link assertSafeSegment} here AND by
+ * `./agent.ts#validateColocatedServerNames` (the CLI deploy-time check
+ * `@guuey/cli`'s `commands/deploy.ts` runs before upload), so a bad
+ * colocated server name is rejected before deploy instead of surfacing only
+ * as a `POD_FATAL_BOOT_ERROR` crash-loop when the pod's `lowerColocated`
+ * calls `colocatedResourceUrl` at boot.
+ */
+export function isValidColocatedServerName(value) {
+    return SAFE_SEGMENT_RE.test(value);
+}
+function assertSafeSegment(value, label) {
+    if (!isValidColocatedServerName(value)) {
+        throw new Error(`colocatedResourceUrl: ${label} "${value}" must match ${SAFE_SEGMENT_RE.source} (it composes a URL path segment and a KV scope key)`);
+    }
+}
+/**
+ * Build the synthetic `https://colocated.guuey.com/<appId>/<serverName>/`
+ * resource URL for a colocated MCP server. Throws if either segment fails
+ * the safe-segment check.
+ */
+export function colocatedResourceUrl(appId, serverName) {
+    assertSafeSegment(appId, 'appId');
+    assertSafeSegment(serverName, 'serverName');
+    return `${COLOCATED_ORIGIN}/${appId}/${serverName}/`;
+}

package/dist/guuey-context.d.ts

@@ -0,0 +1,90 @@
+/**
+ * `GuueyContext` — everything the platform resolved for one turn, handed to a
+ * graceful-mode agent factory. THE import channel for graceful devs:
+ *
+ * ```ts
+ * import type { GuueyContext } from "@guuey/config";
+ * export default (guuey: GuueyContext) => new LlmAgent({
+ *   model: guuey.model,
+ *   // Function form — safe for every framework; required for ADK, which
+ *   // applies `{var}` substitution to a plain-string instruction.
+ *   instruction: () => guuey.instruction,
+ *   tools: [myTool, ...guuey.mcpToolsets],
+ * });
+ * ```
+ *
+ * Types-only and dependency-free by design (`@guuey/config` is already a
+ * template dependency; the host — which ASSEMBLES the context — is not). The
+ * tiny shapes below are structurally identical to `@guuey/worker`'s protocol
+ * types; duplicating them here keeps config free of a runtime package
+ * dependency for what is purely a type channel.
+ *
+ * The factory runs PER INVOKE (matching the per-invoke agent construction the
+ * platform host has always done), so per-turn surfaces — the user, this
+ * turn's state — are first-class, not bolted on.
+ */
+/** Router-vouched end-user identity for this turn (multi-tenant). */
+export interface GuueyContextUser {
+    id: string;
+    authMode: "anonymous" | "authenticated";
+}
+/**
+ * The three GuueyFS layer mounts (absolute paths):
+ *  - `app` — read-only app assets,
+ *  - `home` — per-USER durable storage,
+ *  - `session` — per-session scratch.
+ */
+export interface GuueyContextFiles {
+    app: string;
+    home: string;
+    session: string;
+}
+/** One prior message from the recent history window. */
+export interface GuueyContextMessage {
+    role: "user" | "agent";
+    text: string;
+}
+/** One thread-memory record folded from prior turns. */
+export interface GuueyContextMemoryRecord {
+    key?: string;
+    value: unknown;
+}
+/**
+ * The full per-turn platform context. `TToolset` is the framework's MCP
+ * toolset type (e.g. `MCPToolset` from `@google/adk`) — defaults to `unknown`
+ * so the type stays framework-neutral.
+ *
+ * History, memory, and working state are ALSO auto-injected into
+ * `instruction` as the standard context preamble — a factory that ignores
+ * them still yields a conversational agent. They appear here read-only so an
+ * advanced factory can do better than the default preamble.
+ */
+export interface GuueyContext<TToolset = unknown> {
+    /** Resolved model id (from guuey.json / registry default). */
+    model: string;
+    /**
+     * The system prompt WITH the standard context preamble (history, thread
+     * memory, working state) already prepended. Feed this to the agent unless
+     * you are rendering context yourself from the raw fields below.
+     */
+    instruction: string;
+    /** Ready-to-use MCP toolsets for every server declared in guuey.json. */
+    mcpToolsets: TToolset[];
+    /** The end user this turn serves. */
+    user: GuueyContextUser;
+    /** The three-tier file storage paths. */
+    files: GuueyContextFiles;
+    /** Recent conversation window (read side; auto-preambled). */
+    history: GuueyContextMessage[];
+    /** Thread memory records (read side; auto-preambled). */
+    memory: GuueyContextMemoryRecord[];
+    /** Prior working state carried from the previous turn (read side). */
+    workingState: unknown | undefined;
+}
+/**
+ * What a graceful agent module's default export may be: the framework-native
+ * agent object itself, or a factory receiving the {@link GuueyContext}.
+ * Factories may be async.
+ */
+export type GuueyAgentExport<TAgent = object, TToolset = unknown> = TAgent | ((guuey: GuueyContext<TToolset>) => TAgent | Promise<TAgent>);
+//# sourceMappingURL=guuey-context.d.ts.map

package/dist/guuey-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guuey-context.d.ts","sourceRoot":"","sources":["../src/guuey-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,qEAAqE;AACrE,MAAM,WAAW,gBAAgB;IAC/B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,WAAW,GAAG,eAAe,CAAC;CACzC;AAED;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,wDAAwD;AACxD,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;CACd;AAED,wDAAwD;AACxD,MAAM,WAAW,wBAAwB;IACvC,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,OAAO,CAAC;CAChB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,YAAY,CAAC,QAAQ,GAAG,OAAO;IAC9C,8DAA8D;IAC9D,KAAK,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB,yEAAyE;IACzE,WAAW,EAAE,QAAQ,EAAE,CAAC;IACxB,qCAAqC;IACrC,IAAI,EAAE,gBAAgB,CAAC;IACvB,yCAAyC;IACzC,KAAK,EAAE,iBAAiB,CAAC;IACzB,8DAA8D;IAC9D,OAAO,EAAE,mBAAmB,EAAE,CAAC;IAC/B,yDAAyD;IACzD,MAAM,EAAE,wBAAwB,EAAE,CAAC;IACnC,sEAAsE;IACtE,YAAY,EAAE,OAAO,GAAG,SAAS,CAAC;CACnC;AAED;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,CAAC,MAAM,GAAG,MAAM,EAAE,QAAQ,GAAG,OAAO,IAC5D,MAAM,GACN,CAAC,CAAC,KAAK,EAAE,YAAY,CAAC,QAAQ,CAAC,KAAK,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC"}

package/dist/guuey-context.js

@@ -0,0 +1,26 @@
+/**
+ * `GuueyContext` — everything the platform resolved for one turn, handed to a
+ * graceful-mode agent factory. THE import channel for graceful devs:
+ *
+ * ```ts
+ * import type { GuueyContext } from "@guuey/config";
+ * export default (guuey: GuueyContext) => new LlmAgent({
+ *   model: guuey.model,
+ *   // Function form — safe for every framework; required for ADK, which
+ *   // applies `{var}` substitution to a plain-string instruction.
+ *   instruction: () => guuey.instruction,
+ *   tools: [myTool, ...guuey.mcpToolsets],
+ * });
+ * ```
+ *
+ * Types-only and dependency-free by design (`@guuey/config` is already a
+ * template dependency; the host — which ASSEMBLES the context — is not). The
+ * tiny shapes below are structurally identical to `@guuey/worker`'s protocol
+ * types; duplicating them here keeps config free of a runtime package
+ * dependency for what is purely a type channel.
+ *
+ * The factory runs PER INVOKE (matching the per-invoke agent construction the
+ * platform host has always done), so per-turn surfaces — the user, this
+ * turn's state — are first-class, not bolted on.
+ */
+export {};

package/dist/index.d.ts

@@ -12,10 +12,12 @@
  */
 export * from './schema.js';
 export * from './agent.js';
+export * from './colocated.js';
 export * from './app.js';
 export * from './ggui.js';
 export * from './loader.js';
 export * from './hosting.js';
 export * from './system-prompt.js';
 export * from './registry.js';
+export * from './guuey-context.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC;AAC9B,cAAc,oBAAoB,CAAC"}

package/dist/index.js

@@ -12,9 +12,11 @@
  */
 export * from './schema.js';
 export * from './agent.js';
+export * from './colocated.js';
 export * from './app.js';
 export * from './ggui.js';
 export * from './loader.js';
 export * from './hosting.js';
 export * from './system-prompt.js';
 export * from './registry.js';
+export * from './guuey-context.js';

package/dist/registry.d.ts

@@ -18,6 +18,13 @@ export interface FrameworkEntry {
     readonly facetSupportedRange: string | null;
     readonly defaultProvider: "anthropic" | "openai" | "google";
 }
+/**
+ * Array order is picker order AFTER `modelsForProvider` floats the default to
+ * the front — the platform's app-behavior picker shows only `.slice(0, 2)` for
+ * google + openai, so the second array entry per provider is a product-visible
+ * choice, not incidental. Pinned by
+ * `apps/platform/.../ModelSection/ModelSection.test.ts`.
+ */
 export declare const MODEL_REGISTRY: readonly ModelEntry[];
 export declare const FRAMEWORK_REGISTRY: readonly FrameworkEntry[];
 /**

package/dist/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,MAAM,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,WAAW,GAAG,YAAY,CAAC;AAExE,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,QAAQ,EAAE,WAAW,GAAG,QAAQ,GAAG,QAAQ,GAAG,YAAY,CAAC;IACpE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,SAAS,CAAC,EAAE,IAAI,CAAC;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,SAAS,EAAE,kBAAkB,GAAG,mBAAmB,GAAG,YAAY,GAAG,SAAS,CAAC;IACxF,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,qBAAqB,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9C,QAAQ,CAAC,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C,QAAQ,CAAC,eAAe,EAAE,WAAW,GAAG,QAAQ,GAAG,QAAQ,CAAC;CAC7D;AAED,eAAO,MAAM,cAAc,EAAE,SAAS,UAAU,EAe/C,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,SAAS,cAAc,EA6BvD,CAAC;AAEF;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,UAAU,CAAC,UAAU,CAAC,GAAG,SAAS,UAAU,EAAE,CAQlF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,cAAc,CAAC,WAAW,CAAC,GAAG,MAAM,CAM9E;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAE7D"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../src/registry.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,MAAM,MAAM,WAAW,GAAG,IAAI,GAAG,SAAS,GAAG,WAAW,GAAG,YAAY,CAAC;AAExE,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,QAAQ,EAAE,WAAW,GAAG,QAAQ,GAAG,QAAQ,GAAG,YAAY,CAAC;IACpE,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,QAAQ,CAAC,SAAS,CAAC,EAAE,IAAI,CAAC;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,SAAS,EAAE,kBAAkB,GAAG,mBAAmB,GAAG,YAAY,GAAG,SAAS,CAAC;IACxF,QAAQ,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,QAAQ,CAAC,qBAAqB,EAAE,MAAM,GAAG,IAAI,CAAC;IAC9C,QAAQ,CAAC,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5C,QAAQ,CAAC,eAAe,EAAE,WAAW,GAAG,QAAQ,GAAG,QAAQ,CAAC;CAC7D;AAED;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,EAAE,SAAS,UAAU,EA0B/C,CAAC;AAEF,eAAO,MAAM,kBAAkB,EAAE,SAAS,cAAc,EA6BvD,CAAC;AAEF;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,UAAU,CAAC,UAAU,CAAC,GAAG,SAAS,UAAU,EAAE,CAQlF;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,cAAc,CAAC,WAAW,CAAC,GAAG,MAAM,CAM9E;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAE7D"}

package/dist/registry.js

@@ -2,18 +2,36 @@
  * Model + framework registry — single source of truth per the model-release
  * playbook §8 item A; a release = one entry change here + rate-card row.
  */
+/**
+ * Array order is picker order AFTER `modelsForProvider` floats the default to
+ * the front — the platform's app-behavior picker shows only `.slice(0, 2)` for
+ * google + openai, so the second array entry per provider is a product-visible
+ * choice, not incidental. Pinned by
+ * `apps/platform/.../ModelSection/ModelSection.test.ts`.
+ */
 export const MODEL_REGISTRY = [
     { id: "claude-sonnet-5", provider: "anthropic", label: "Claude Sonnet 5", status: "ga", isDefault: true },
     { id: "claude-fable-5", provider: "anthropic", label: "Claude Fable 5", status: "ga" },
+    { id: "claude-opus-5", provider: "anthropic", label: "Claude Opus 5", status: "ga" },
     { id: "claude-sonnet-4-6", provider: "anthropic", label: "Claude Sonnet 4.6", status: "ga" },
     { id: "claude-haiku-4-5", provider: "anthropic", label: "Claude Haiku 4.5", status: "ga" },
     { id: "claude-opus-4-8", provider: "anthropic", label: "Claude Opus 4.8", status: "ga" },
-    { id: "gpt-5.5", provider: "openai", label: "GPT-5.5", status: "ga", isDefault: true },
+    // Terra — guuey's OpenAI default (founder call 2026-07-25). This DELIBERATELY
+    // diverges from OpenAI's own `gpt-5.6` alias, which routes to Sol: Terra is
+    // half Sol's price and the better cost/balance pick for hosted agent
+    // workloads. The bare `gpt-5.6` alias is intentionally NOT a registry id
+    // (never offered in a picker) — the rate card still rows it at Sol's price so
+    // an alias call from BYO config can't under-meter.
+    { id: "gpt-5.6-terra", provider: "openai", label: "GPT-5.6 Terra", status: "ga", isDefault: true },
+    { id: "gpt-5.6-sol", provider: "openai", label: "GPT-5.6 Sol", status: "ga" },
+    { id: "gpt-5.6-luna", provider: "openai", label: "GPT-5.6 Luna", status: "ga" },
+    { id: "gpt-5.5", provider: "openai", label: "GPT-5.5", status: "ga" },
     { id: "gpt-5.4", provider: "openai", label: "GPT-5.4", status: "ga" },
     { id: "gpt-4o", provider: "openai", label: "GPT-4o", status: "ga" },
     { id: "gpt-4o-mini", provider: "openai", label: "GPT-4o Mini", status: "ga" },
-    { id: "gpt-5.6", provider: "openai", label: "GPT-5.6", status: "announced" },
-    { id: "gemini-3.5-flash", provider: "google", label: "Gemini 3.5 Flash", status: "ga", isDefault: true },
+    { id: "gemini-3.6-flash", provider: "google", label: "Gemini 3.6 Flash", status: "ga", isDefault: true },
+    { id: "gemini-3.5-flash-lite", provider: "google", label: "Gemini 3.5 Flash Lite", status: "ga" },
+    { id: "gemini-3.5-flash", provider: "google", label: "Gemini 3.5 Flash", status: "ga" },
     { id: "gemini-3.1-pro", provider: "google", label: "Gemini 3.1 Pro", status: "ga" },
     { id: "gemini-2.5-flash", provider: "google", label: "Gemini 2.5 Flash", status: "ga" },
     { id: "gemini-2.5-pro", provider: "google", label: "Gemini 2.5 Pro", status: "ga" },
@@ -35,9 +53,9 @@ export const FRAMEWORK_REGISTRY = [
     },
     {
         framework: "google-adk",
-        sdkPackage: "google-adk",
-        platformPinnedVersion: "2.3.0",
-        facetSupportedRange: null,
+        sdkPackage: "@google/adk", // the OFFICIAL JS ADK (the Python lane retired with guuey_adk_host)
+        platformPinnedVersion: "1.3.0", // pinned in @guuey-private/host-shared
+        facetSupportedRange: ">=1.0.0 <2", // @silverprotocol/google-adk peer range
         defaultProvider: "google",
     },
     {

package/dist/schema.d.ts

@@ -8,7 +8,7 @@
  * - `ggui`  (optional) — cross-protocol integration if the agent uses ggui rendering
  *
  * Plus top-level platform identity (`appId`, `workspaceId`) populated by
- * the CLI after `guuey create` / `guuey link`.
+ * the CLI after `guuey create` / `guuey pull --app-id`.
  *
  * **Filename convention** (filename = artifact kind, see design doc §3):
  * ```
@@ -48,8 +48,8 @@ import { type GuueyGguiSection } from './ggui.js';
  * only an MCP server uses `guuey.mcp.json` instead (separate schema).
  *
  * `appId` and `workspaceId` are platform-resolved identifiers stamped by
- * the CLI after `guuey create` / `guuey link`. A fresh project has neither.
- * After first `guuey create`, both may be present.
+ * the CLI after `guuey create` / `guuey pull --app-id`. A fresh project has
+ * neither. After first `guuey create`, both may be present.
  *
  * Re-exports the sub-section types for consumer convenience.
  */
@@ -68,6 +68,7 @@ export declare const GuueyJsonV1: z.ZodObject<{
             "google-adk": "google-adk";
             vanilla: "vanilla";
         }>>;
+        entry: z.ZodOptional<z.ZodString>;
         model: z.ZodOptional<z.ZodString>;
         modelProvider: z.ZodOptional<z.ZodEnum<{
             openai: "openai";
@@ -76,11 +77,10 @@ export declare const GuueyJsonV1: z.ZodObject<{
         systemPrompt: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
             file: z.ZodString;
         }, z.core.$strict>]>>;
-        mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mcpServers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodDiscriminatedUnion<[z.ZodObject<{
             kind: z.ZodLiteral<"colocated">;
-            command: z.ZodString;
-            args: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            source: z.ZodString;
+            devPort: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strict>, z.ZodObject<{
             kind: z.ZodLiteral<"hosted">;
             server: z.ZodOptional<z.ZodString>;
@@ -99,7 +99,12 @@ export declare const GuueyJsonV1: z.ZodObject<{
             federate: z.ZodOptional<z.ZodBoolean>;
             headers: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
             devPort: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strict>], "kind">>>;
+            mcpResourceUrl: z.ZodOptional<z.ZodURL>;
+            profileAccess: z.ZodOptional<z.ZodEnum<{
+                read: "read";
+                "read-write": "read-write";
+            }>>;
+        }, z.core.$strict>], "kind">, z.ZodLiteral<false>]>>>;
         tools: z.ZodOptional<z.ZodObject<{
             allowlist: z.ZodOptional<z.ZodArray<z.ZodString>>;
             denylist: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -130,6 +135,10 @@ export declare const GuueyJsonV1: z.ZodObject<{
             user: "user";
             app: "app";
         }>>>;
+        profileAccess: z.ZodOptional<z.ZodEnum<{
+            read: "read";
+            "read-write": "read-write";
+        }>>;
         env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         secrets: z.ZodOptional<z.ZodArray<z.ZodString>>;
         endpoint: z.ZodOptional<z.ZodObject<{

package/dist/schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAkB,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7D,OAAO,EAAgB,KAAK,QAAQ,EAAE,MAAM,UAAU,CAAC;AACvD,OAAO,EAAiB,KAAK,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAEjE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAmDtB,CAAC;AAEH,kDAAkD;AAClD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEtD;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAG3D,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,gBAAgB,EAAE,CAAC;AAEvD;;;GAGG;AACH,eAAO,MAAM,mBAAmB,eAAe,CAAC;AAEhD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,WAAW,CAExD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,OAAO,GACX,UAAU,CAAC,OAAO,WAAW,CAAC,SAAS,CAAC,CAE1C"}
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAkB,KAAK,UAAU,EAAE,MAAM,YAAY,CAAC;AAC7D,OAAO,EAAgB,KAAK,QAAQ,EAAE,MAAM,UAAU,CAAC;AACvD,OAAO,EAAiB,KAAK,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAEjE;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAmDtB,CAAC;AAEH,kDAAkD;AAClD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAEtD;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAG3D,YAAY,EAAE,UAAU,EAAE,QAAQ,EAAE,gBAAgB,EAAE,CAAC;AAEvD;;;GAGG;AACH,eAAO,MAAM,mBAAmB,eAAe,CAAC;AAEhD;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,GAAG,EAAE,OAAO,GAAG,WAAW,CAExD;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAChC,GAAG,EAAE,OAAO,GACX,UAAU,CAAC,OAAO,WAAW,CAAC,SAAS,CAAC,CAE1C"}

package/dist/schema.js

@@ -8,7 +8,7 @@
  * - `ggui`  (optional) — cross-protocol integration if the agent uses ggui rendering
  *
  * Plus top-level platform identity (`appId`, `workspaceId`) populated by
- * the CLI after `guuey create` / `guuey link`.
+ * the CLI after `guuey create` / `guuey pull --app-id`.
  *
  * **Filename convention** (filename = artifact kind, see design doc §3):
  * ```
@@ -48,8 +48,8 @@ import { GguiSectionV1 } from './ggui.js';
  * only an MCP server uses `guuey.mcp.json` instead (separate schema).
  *
  * `appId` and `workspaceId` are platform-resolved identifiers stamped by
- * the CLI after `guuey create` / `guuey link`. A fresh project has neither.
- * After first `guuey create`, both may be present.
+ * the CLI after `guuey create` / `guuey pull --app-id`. A fresh project has
+ * neither. After first `guuey create`, both may be present.
  *
  * Re-exports the sub-section types for consumer convenience.
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@guuey/config",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Open-source schemas + loaders for the three guuey config files: agent.json (declarative agent definition), guuey.json (hosted-deploy overlay), and the helper types around them. Consumed by @guuey/cli, the guuey backend, and devs writing their own agent or MCP server.",
   "license": "MIT",
   "type": "module",
@@ -16,6 +16,16 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "default": "./dist/index.js"
+    },
+    "./registry": {
+      "types": "./dist/registry.d.ts",
+      "import": "./dist/registry.js",
+      "default": "./dist/registry.js"
+    },
+    "./browser": {
+      "types": "./dist/browser.d.ts",
+      "import": "./dist/browser.js",
+      "default": "./dist/browser.js"
     }
   },
   "dependencies": {