@noodleseed/one 0.188.0 → 0.190.0

package/node_modules/@noodle-borg/agent-kit/dist/behavior-skills.js

@@ -15,7 +15,7 @@ export const EXPECTED_BEHAVIOR_SKILL_NAMES = [
 export const BEHAVIOR_SKILLS = [
     {
         name: 'designing-mcp-products',
-        description: 'Use when a Noodle Seed MCP product idea needs conversational fit, user benefit, scope, interaction, or evidence design before implementation.',
+        description: 'Design a Noodle Seed MCP product or choose its first workflow. Use when the user benefit, conversational fit, scope, or evidence level is unclear.',
         outcome: 'Produce the smallest decision-ready MCP product design before code or hosted mutation.',
         positiveTriggers: [
             'Turn a vague product idea into an MCP product.',
@@ -147,7 +147,7 @@ export const BEHAVIOR_SKILLS = [
     },
     {
         name: 'embedding-mcp-assistants',
-        description: 'Use when embedding a Noodle assistant into an existing SaaS or web application, or improving signup or onboarding conversion with public-to-product onboarding, with browser, identity, session, and credential boundaries.',
+        description: 'Embed a Noodle Seed assistant in a website or SaaS app, including public-to-product onboarding. Use for browser mounting, sessions, identity, or customer-specific routing.',
         outcome: 'Select one decision-complete assistant topology, including the dual-surface continuous-onboarding default when it fits, then deliver the embed with identity and credential separation proven at the tested level.',
         positiveTriggers: [
             'Embed the Noodle assistant in an existing web app.',
@@ -167,10 +167,16 @@ export const BEHAVIOR_SKILLS = [
             'For a first-workflow recommendation: evidence for a public visitor surface, account boundary, useful pre-account result, and authenticated outcome.',
         ],
         primaryReference: 'references/embedded-assistant.md',
-        supportingReferences: ['references/authoring-workflow.md'],
-        evidence: 'One architecture brief owns the selected topology, and the embed works at the requested boundary without forwarding inbound credentials to business backends.',
+        supportingReferences: [
+            'references/embedded-assistant-messaging.md',
+            'references/embedded-assistant-identity.md',
+            'references/embedded-assistant-rendering.md',
+            'references/embedded-assistant-operations.md',
+            'references/authoring-workflow.md',
+        ],
+        evidence: 'The selected topology and trust boundaries are clear, and the embed works at the requested evidence level without forwarding inbound credentials to business backends.',
         recovery: 'Localize failures to origin, session exchange, browser mount, MCP surface, or hosted configuration.',
-        stop: 'Stop before code when the user, job, workflow, access, identity, origin, routing, renderer, model owner, or evidence target is unresolved; hand vague product intent to designing-mcp-products.',
+        stop: 'Clarify any missing identity, origin, routing, or model ownership needed for the next change; continue independent work within the requested scope.',
     },
     {
         name: 'verifying-mcp-delivery',
@@ -215,7 +221,7 @@ export const BEHAVIOR_SKILLS = [
         primaryReference: 'references/verify-and-recover.md',
         supportingReferences: ['references/troubleshooting.md', 'references/inspect-hosted.md'],
         evidence: 'The failed layer is rerun successfully, or the stable blocker and exact next action are reported.',
-        recovery: 'After two attempts with the same signature, stop editing and preserve the repro and passing layers.',
+        recovery: 'If the same failure persists without a new evidence-backed repair, preserve the repro and passing layers and report the blocker.',
         stop: 'Stop before hosted mutation unless the user separately requests deploying-mcp-services.',
     },
     {
@@ -294,38 +300,16 @@ export function renderBehaviorSkillBody(skill, _target) {
         '',
         skill.outcome,
         '',
-        '## Use when',
-        '',
-        ...skill.positiveTriggers.map((trigger) => `- ${trigger}`),
-        '',
-        '## Do not use when',
-        '',
-        ...skill.negativeTriggers.map((trigger) => `- ${trigger}`),
-        '',
-        '## Required inputs',
+        `Read [the workflow](./${skill.primaryReference}) for this task. Read other references only for the relevant concern:`,
+        ...skill.supportingReferences.map((reference) => `- [${reference}](./${reference})`),
+        ...(skill.supportingReferences.length === 0 ? ['- No additional reference is required.'] : []),
         '',
+        'Establish the inputs needed for the requested outcome:',
         ...skill.requiredInputs.map((entry) => `- ${entry}`),
         '',
-        '## Workflow',
-        '',
-        `Read and follow the canonical playbook at \`${skill.primaryReference}\`. It owns the workflow; do not recreate it here or load the command catalog speculatively.`,
-        ...skill.supportingReferences.map((reference) => `Load the supporting reference at \`${reference}\` only when the playbook or observed evidence names that concern.`),
-        '',
-        '## Verification evidence',
-        '',
-        skill.evidence,
-        '',
-        '## Recovery paths',
-        '',
-        skill.recovery,
-        '',
-        '## Stop conditions',
-        '',
-        skill.stop,
-        '',
-        '## Handoff contract',
-        '',
-        'Pass the selected outcome, explicit target, changed files, commands run, passing evidence, first unproven evidence layer, sanitized failure, remaining authority, and exact next action. The receiving skill continues from that layer; do not restart discovery or discard prior proof.',
+        `Done when: ${skill.evidence}`,
+        `If blocked: ${skill.recovery}`,
+        `Boundary: ${skill.stop}`,
     ].join('\n');
 }
 //# sourceMappingURL=behavior-skills.js.map

package/node_modules/@noodle-borg/agent-kit/dist/generated/example-files.js

@@ -86,7 +86,7 @@ export const BUNDLED_EXAMPLE_FILES = [
     { relPath: "examples/google-bigquery/src/server.ts", content: "import {\n  annotations,\n  bind,\n  connection,\n  connector,\n  googleWorkloadIdentity,\n  server,\n  tool,\n  variable,\n  z,\n} from '@noodleseed/one';\n\nconst BIGQUERY_ORIGIN = 'https://bigquery.googleapis.com';\nconst BIGQUERY_READONLY = 'https://www.googleapis.com/auth/bigquery.readonly';\n\nconst bigquery = connector('google_bigquery')\n  .version('1.0.0')\n  .http({\n    baseUrl: BIGQUERY_ORIGIN,\n    allowedOrigins: [BIGQUERY_ORIGIN],\n    credentialProfiles: { google_wif: { kind: 'bearer' } },\n    operations: {\n      query: {\n        type: 'read',\n        method: 'POST',\n        path: '/bigquery/v2/projects/${args.project_id}/queries',\n        input: z.object({\n          project_id: z.string().min(1),\n          query: z.string().min(1),\n          max_results: z.number().int().min(1).max(1000).optional(),\n        }),\n        output: z.object({\n          job_complete: z.boolean().optional(),\n          schema: z.unknown().optional(),\n          rows: z.array(z.unknown()).optional(),\n          total_rows: z.string().optional(),\n        }),\n        request: {\n          query: '${args.query}',\n          useLegacySql: false,\n          maxResults: '${args.max_results}',\n        },\n        response: {\n          job_complete: '${response.jobComplete}',\n          schema: '${response.schema}',\n          rows: '${response.rows}',\n          total_rows: '${response.totalRows}',\n        },\n        credentials: {\n          profiles: ['google_wif'],\n          scopes: [BIGQUERY_READONLY],\n          audience: BIGQUERY_ORIGIN,\n        },\n      },\n    },\n  });\n\nconst google = connection(\n  'customer_google_cloud',\n  googleWorkloadIdentity({\n    provider: variable('GOOGLE_WIF_PROVIDER'),\n    access: {\n      kind: 'serviceAccountImpersonation',\n      serviceAccount: variable('GOOGLE_SERVICE_ACCOUNT'),\n    },\n  }),\n);\n\nexport default server(\n  'google_bigquery',\n  {\n    title: 'Google BigQuery Reader',\n    version: '1.0.0',\n    use: {\n      bigquery: bind(bigquery, { profile: 'google_wif', connection: google }),\n    },\n    instructions:\n      'Run read-only GoogleSQL queries in the configured customer BigQuery project. Never invent project, dataset, or table names.',\n  },\n  [\n    tool('query_bigquery', {\n      title: 'Query BigQuery',\n      description:\n        'Run one read-only GoogleSQL query in an explicitly named Google Cloud project and return the typed BigQuery rows.',\n      input: z.object({\n        project_id: z.string().min(1).meta({ title: 'Google Cloud project' }),\n        query: z.string().min(1).meta({ title: 'GoogleSQL query' }),\n        max_results: z.number().int().min(1).max(1000).optional(),\n      }),\n      output: z.object({\n        job_complete: z.boolean(),\n        schema: z.unknown().optional(),\n        rows: z.array(z.unknown()),\n        total_rows: z.string().optional(),\n      }),\n      annotations: annotations.readOnly(),\n      fulfil({ input, connectors }) {\n        const result = connectors.bigquery.query({\n          project_id: input.project_id,\n          query: input.query,\n          max_results: input.max_results,\n        });\n        return {\n          job_complete: result.job_complete,\n          schema: result.schema.optional(),\n          rows: result.rows,\n          total_rows: result.total_rows.optional(),\n        };\n      },\n    }),\n  ],\n);\n" },
     { relPath: "examples/google-bigquery/test/server.test.ts", content: "import { describe, expect, it } from 'vitest';\nimport app from '../src/server.js';\n\ndescribe('Google BigQuery workload-identity flagship', () => {\n  it('binds a read-only Google operation to keyless service-account impersonation', async () => {\n    const manifest = await app.toManifest();\n    expect(manifest.connectors?.bigquery).toMatchObject({\n      id: 'google_bigquery',\n      binding: {\n        profile: 'google_wif',\n        connection: {\n          id: 'customer_google_cloud',\n          source: {\n            kind: 'googleWorkloadIdentity',\n            provider: '${env.GOOGLE_WIF_PROVIDER}',\n            access: {\n              kind: 'serviceAccountImpersonation',\n              serviceAccount: '${env.GOOGLE_SERVICE_ACCOUNT}',\n            },\n          },\n        },\n      },\n    });\n    expect(app.toConnectorCatalog()).toMatchObject({\n      connectors: [\n        {\n          credentialProfiles: { google_wif: { kind: 'bearer' } },\n          operations: {\n            query: {\n              credentials: {\n                profiles: ['google_wif'],\n                scopes: ['https://www.googleapis.com/auth/bigquery.readonly'],\n                audience: 'https://bigquery.googleapis.com',\n              },\n            },\n          },\n        },\n      ],\n    });\n    expect(JSON.stringify({ manifest, catalog: app.toConnectorCatalog() })).not.toMatch(\n      /private[_-]?key|client[_-]?secret|access[_-]?token/i,\n    );\n  });\n});\n" },
     { relPath: "examples/google-bigquery/vitest.config.ts", content: "import { defineConfig } from 'vitest/config';\n\nexport default defineConfig({\n  resolve: {\n    alias: {\n      '@noodleseed/one': new URL('../../packages/authoring/src/index.ts', import.meta.url).pathname,\n      '@noodle-borg/capabilities': new URL(\n        '../../packages/capabilities/src/index.ts',\n        import.meta.url,\n      ).pathname,\n      '@noodle-borg/compiler': new URL('../../packages/compiler/src/index.ts', import.meta.url)\n        .pathname,\n      '@noodle-borg/connector-defs': new URL(\n        '../../packages/connector-defs/src/index.ts',\n        import.meta.url,\n      ).pathname,\n    },\n  },\n  test: { include: ['test/**/*.test.ts'] },\n});\n" },
-    { relPath: "examples/hello/README.md", content: "# hello — minimal TypeScript quickstart\n\nThe smallest deployable Noodle app: a single `greet` tool authored in TypeScript with no\nconnectors, secrets, flows, widgets, or handoff policy. It still uses the current server options form\nso new authors see where server-level branding belongs. Use it for a local read or first deploy.\nFor a new project, `noodle init --template hello` also supplies isolated behavior tests: compilation,\ntool discovery, an expected greeting and invalid-input rejection. Init installs pinned local tooling and runs\nthose checks; use `npm run agent:check` after edits. `--no-install` prepares files without verified readiness.\nIf setup fails, repair its reported stage and repeat the safe resume command; do not overwrite your edits.\n\nProtocol negotiation deliberately does not appear in `src/server.ts` or `noodle.json`. MCP versions\nare platform-owned: the same deployed app automatically serves compatible legacy clients and modern\nclients from its existing endpoint, without an app setting or redeploy.\n\nWhen an installed Noodle Developer plugin drives this example, its skill performs mapped lifecycle\nsteps through the supported `noodle-readiness` tools and reports only stable public `noodle ...`\ncommands as recovery text. Do not install or update a global CLI: the coding agent writes and tests\nthis source while Noodle guides and operates the validate, preview, deploy, inspect, and debug workflow.\nPlugin sign-in uses one compact consent for the Developer MCP resource; it does not ask the user to\nchoose organizations or environments. For remote inspection, the agent calls `get_context`, resolves\nthe intended organization from the request or this project, and passes that explicit `org` to every\nscoped tool. The local CLI may keep its own default organization for command convenience.\nFor an approved implementation plan, the installed `executing-noodle-plans` skill owns the\ntest-first task, review, recovery, and final-verification loop.\nIf that agent discovers a Noodle Seed product gap while working, the installed skill prepares a\nsanitized `noodle feedback` proposal, discovers current fields from `noodle commands --json`, and\npreviews the exact normalized submission, diagnostics, and private destination through the typed\nplugin function or `--dry-run --json`. It includes its known `--agent` and `--model` identity without\nguessing unavailable values, keeps those fields structured, and submits once only after explicit user\napproval of that exact preview; it never composes a shell wrapper, auto-logs in, or retry-loops.\nEvery `--json` command writes its canonical success or failure envelope to stdout and leaves stderr\nempty. One-shot commands write one envelope; streaming commands write NDJSON snapshot, event, and\nterminal-failure envelopes so agents can parse each line independently.\n\n```sh\nnoodle test examples/hello/src/server.ts --tool greet --args '{\"name\":\"Ada\"}' --json\nnoodle dev examples/hello/src/server.ts --app hello\nnoodle deploy examples/hello/src/server.ts --org acme --app hello\n```\n\n`noodle export manifest examples/hello/src/server.ts` compiles the same entrypoint locally and prints\nthe portable, vendor-neutral manifest JSON — the eject path: your `server.ts` plus this manifest is\nthe whole app, yours to read, diff, and keep.\n\nIt is also the fixture for `pnpm smoke:dev` and the e2e harness, so keep its tool surface stable.\n" },
+    { relPath: "examples/hello/README.md", content: "# hello — minimal TypeScript quickstart\n\nThe smallest deployable Noodle app: a single `greet` tool authored in TypeScript with no\nconnectors, secrets, flows, widgets, or handoff policy. It still uses the current server options form\nso new authors see where server-level branding belongs. Use it for a local read or first deploy.\nFor a new project, `noodle init --template hello` also supplies isolated behavior tests: compilation,\ntool discovery, an expected greeting and invalid-input rejection. Init installs pinned local tooling and runs\nthose checks; use `npm run agent:check` after edits. `--no-install` prepares files without verified readiness.\nIf setup fails, repair its reported stage and repeat the safe resume command; do not overwrite your edits.\n\nProtocol negotiation deliberately does not appear in `src/server.ts` or `noodle.json`. MCP versions\nare platform-owned: the same deployed app automatically serves compatible legacy clients and modern\nclients from its existing endpoint, without an app setting or redeploy.\n\nWhen an installed Noodle Developer plugin drives this example, its skill performs mapped lifecycle\nsteps through the supported `noodle-readiness` tools and reports only stable public `noodle ...`\ncommands as recovery text. Do not install or update a global CLI: the coding agent writes and tests\nthis source while Noodle guides and operates the validate, preview, deploy, inspect, and debug workflow.\nPlugin sign-in uses one compact consent for the Developer MCP resource; it does not ask the user to\nchoose organizations or environments. For remote inspection, the agent calls `get_context`, resolves\nthe intended organization from the request or this project, and passes that explicit `org` to every\nscoped tool. The local CLI may keep its own default organization for command convenience.\nFor an approved implementation plan, follow the project's own development workflow and the\nrelevant Noodle authoring or verification skill.\nIf that agent discovers a Noodle Seed product gap while working, the installed skill prepares a\nsanitized `noodle feedback` proposal, discovers current fields from `noodle commands --json`, and\npreviews the exact normalized submission, diagnostics, and private destination through the typed\nplugin function or `--dry-run --json`. It includes its known `--agent` and `--model` identity without\nguessing unavailable values, keeps those fields structured, and submits once only after explicit user\napproval of that exact preview; it never composes a shell wrapper, auto-logs in, or retry-loops.\nEvery `--json` command writes its canonical success or failure envelope to stdout and leaves stderr\nempty. One-shot commands write one envelope; streaming commands write NDJSON snapshot, event, and\nterminal-failure envelopes so agents can parse each line independently.\n\n```sh\nnoodle test examples/hello/src/server.ts --tool greet --args '{\"name\":\"Ada\"}' --json\nnoodle dev examples/hello/src/server.ts --app hello\nnoodle deploy examples/hello/src/server.ts --org acme --app hello\n```\n\n`noodle export manifest examples/hello/src/server.ts` compiles the same entrypoint locally and prints\nthe portable, vendor-neutral manifest JSON — the eject path: your `server.ts` plus this manifest is\nthe whole app, yours to read, diff, and keep.\n\nIt is also the fixture for `pnpm smoke:dev` and the e2e harness, so keep its tool surface stable.\n" },
     { relPath: "examples/hello/noodle.json", content: "{\n  \"entrypoint\": \"src/server.ts\",\n  \"name\": \"hello\",\n  \"template\": \"hello\"\n}\n" },
     { relPath: "examples/hello/package.json", content: "{\n  \"name\": \"hello\",\n  \"version\": \"0.1.0\",\n  \"private\": true,\n  \"type\": \"module\",\n  \"scripts\": {\n    \"test\": \"vitest run --dir test\",\n    \"validate\": \"noodle validate\",\n    \"dev\": \"noodle dev\",\n    \"deploy\": \"noodle deploy\"\n  },\n  \"devDependencies\": {\n    \"@noodleseed/one\": \"latest\",\n    \"vitest\": \"latest\"\n  }\n}\n" },
     { relPath: "examples/hello/src/server.ts", content: "import { annotations, server, tool, z } from '@noodleseed/one';\n\n// Customer apps stay on the public SDK; @noodle-borg/* packages are runtime implementation details.\n\nexport default server(\n  'hello',\n  {\n    title: 'Hello',\n    version: '1.0.0',\n    branding: {\n      name: 'Hello',\n      accent: '#1D9E75',\n      radius: 'md',\n      density: 'comfortable',\n    },\n  },\n  [\n    tool('greet', {\n      // Every model-visible tool declares a title: hosts show it in tool pickers and confirmation\n      // prompts, and both consumer directories reject tools without one.\n      title: 'Greet someone',\n      description: 'Greet someone by name.',\n      input: z.object({\n        // Defaults are advertised to the model and applied at runtime when the argument is omitted.\n        name: z.string().default('world'),\n      }),\n      output: z.object({\n        message: z.string(),\n      }),\n      // Read-only, closed-world: assistant surfaces run this without a consent prompt.\n      annotations: annotations.readOnly(),\n      fulfil: ({ input }) => {\n        return { message: `Hello, ${input.name}!` };\n      },\n    }),\n  ],\n);\n" },

package/node_modules/@noodle-borg/agent-kit/dist/index.d.ts

@@ -3,7 +3,6 @@ export type * from '@noodle-borg/agent-packaging';
 export { HOST_PACKAGING_LIMITS, packageHostTarget } from '@noodle-borg/agent-packaging';
 export * from '@noodle-borg/plugin-distribution';
 export * from './behavior-skills.js';
-export * from './plan-execution-skill.js';
 export * from './plugin-compatibility.js';
 export * from './plugin-copilot-bundle.js';
 export * from './plugin-launcher.js';

package/node_modules/@noodle-borg/agent-kit/dist/index.js

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
 import { BEHAVIOR_SKILLS, renderBehaviorSkillBody } from './behavior-skills.js';
 import { BUNDLED_EXAMPLE_FILES } from './generated/example-files.js';
-import { EXECUTING_NOODLE_PLANS_SKILL } from './plan-execution-skill.js';
+import { AUTHORING_TOPIC_PATHS } from './skill-authoring-split.js';
 import { SKILL_REFERENCES } from './skill-content.js';
 import { defineSkillRegistry, renderRegisteredSkillFiles, } from './skill-registry.js';
 import { SKILL_DESCRIPTION, skillRouterBody } from './skill-router.js';
@@ -9,7 +9,6 @@ import { AGENT_KIT_VERSION } from './version.js';
 export { HOST_PACKAGING_LIMITS, packageHostTarget } from '@noodle-borg/agent-packaging';
 export * from '@noodle-borg/plugin-distribution';
 export * from './behavior-skills.js';
-export * from './plan-execution-skill.js';
 export * from './plugin-compatibility.js';
 export * from './plugin-copilot-bundle.js';
 export * from './plugin-launcher.js';
@@ -29,7 +28,10 @@ const MANAGED_FILE_BY_TARGET = {
 };
 const SKILL_REFERENCE_BY_PATH = new Map(SKILL_REFERENCES.map((reference) => [reference.relPath, reference]));
 function behaviorSkillReferenceFiles(skill) {
-    return [skill.primaryReference, ...skill.supportingReferences].map((path) => {
+    const paths = [skill.primaryReference, ...skill.supportingReferences];
+    if (paths.includes('references/authoring-workflow.md'))
+        paths.push(...AUTHORING_TOPIC_PATHS);
+    return [...new Set(paths)].map((path) => {
         const reference = SKILL_REFERENCE_BY_PATH.get(path);
         if (reference === undefined)
             throw new Error(`missing behavior skill reference: ${path}`);
@@ -66,7 +68,6 @@ export const SKILL_REGISTRY = defineSkillRegistry([
         renderBody: (target) => renderBehaviorSkillBody(skill, target),
         files: behaviorSkillReferenceFiles(skill),
     })),
-    { ...EXECUTING_NOODLE_PLANS_SKILL, version: AGENT_KIT_VERSION },
 ]);
 export function parseAgentTargets(value) {
     if (value === undefined || value === 'all')
@@ -110,29 +111,10 @@ export function renderManagedBlock(input) {
         '# Noodle Seed Project Context',
         '',
         `Agent target: ${input.target === 'codex' ? 'Codex' : 'Claude Code'}.`,
-        '',
-        'Build this project as a Noodle Seed MCP server or app authored in TypeScript. Every `--json` command uses the canonical envelope on stdout and keeps stderr empty: one-shot commands write exactly one envelope on stdout; streaming commands write one NDJSON envelope per line. Drive the loop by parsing machine state — not by reading source or scraping human prose.',
-        '',
-        '## Agent-native loop',
-        '',
-        "- **Applicability**: when the request is unrelated to the Noodle MCP server or app, follow the project's normal instructions and run no Noodle lifecycle commands.",
-        '- **Route first**: read the `noodle-seed` skill `SKILL.md`, choose exactly one primary route for the requested outcome, and read that primary reference. Read supporting references only when the route or observed evidence requires them.',
-        "- Discover: `noodle commands --json` — every command, flag, and exit code (don't read source).",
-        '- Author, when the selected route requires it: edit the configured TypeScript entrypoint — follow that route and its capability references.',
-        '- Validate: `noodle validate --json` → on failure `{ok:false,error:{code,message,fix,next,errors:[{code,path,message}]}}`; per-field detail is in `error.errors[]`.',
-        '- Repair: fix each `error.errors[]` entry at its `path`, re-run validate; `noodle validate --fix-prompt` gives ready repair prose. Never freeform re-edit.',
-        '- Smoke: `noodle test --json`.',
-        '- Continue only to the level the selected route requests: Apps/widgets use `noodle check --json` plus `noodle devtools`; hosted inspection stays read-only; hosted mutation runs only when the current user request explicitly authorizes the exact action and target.',
-        '- Stale skill? `noodle agents doctor --json` → `noodle agents setup --write`.',
-        '',
-        'The exact `--json`/exit-code contract is in the `noodle-seed` skill and its `references/agent-contract.md`. Human-oriented command prose lives in the project README, not here.',
-        '',
-        '## Safety',
-        '',
-        '- Keep secrets, bearer tokens, refresh tokens, static access keys, `.env` / `.env.noodle` values, and `~/.noodle/config.json` out of prompts, logs, docs, tests, and generated files.',
-        '- Do not hand-author manifest JSON or YAML, runtime artifact JSON, connector IR, or hosted asset metadata.',
-        '- Do not add static data-plane credential paths; hosted access is identity-based.',
-        '- Never run `link`, hosted secret/variable/config/access changes, deploy, rollback, host configuration writes, or directory submission unless the current user request explicitly authorizes the exact mutation and target.',
+        'Build this project in its configured TypeScript entrypoint. The compiler owns manifests and runtime artifacts; do not hand-author them.',
+        'For Noodle tasks, choose the relevant installed skill directly; `noodle-seed` helps with setup or unclear tasks. Read its linked reference only when needed. For unrelated work, follow the project instructions.',
+        'Use `noodle commands --json` for current commands and parse `noodle validate --json` errors by code and path. Validate the requested behavior at the appropriate level; local success does not prove a live connector or hosted service.',
+        'Keep credentials out of source, prompts, logs, and browser code. Hosted writes need the authorized action and explicit organization, application, and environment.',
         '',
         '## Project Defaults',
         '',

package/node_modules/@noodle-borg/agent-kit/dist/plugin-bootstrap-skill.js

@@ -5,8 +5,7 @@ import { NOODLE_WORDMARK } from './welcome-wordmark.js';
 export const PLUGIN_NAME = 'noodle-seed';
 /** Cold-start discovery text shared by direct marketplace and official-directory projections. */
 const BOOTSTRAP_SKILL_DESCRIPTION = 'Use when asked to build, create, or ship an MCP server, MCP app, AI app, or connector, or to ' +
-    'make a product, API, or SaaS reachable by AI agents, or when a software business wants to improve ' +
-    'signup or onboarding conversion or choose a first Noodle workflow. Bootstraps Noodle Seed — TypeScript ' +
+    'make a product, API, or SaaS reachable by AI agents. Bootstraps Noodle Seed TypeScript ' +
     'authoring with the noodle CLI, local validation and testing, and governed hosted deployment.';
 function bootstrapRouterBody() {
     return [
@@ -42,12 +41,6 @@ function bootstrapRouterBody() {
             `${PLUGIN_WINDOWS_SUPPORT.installCommand}` +
             '`; never expose a private plugin path as a workaround.',
         '',
-        '## First-workflow default',
-        '',
-        'When the user wants to get started but has not chosen a workflow, inspect the available product and repository context. If more signed-up or signed-in users are valuable and the product has a public visitor entry point, an existing account boundary, a genuine useful result that can be delivered before signup, and a meaningful next action inside the authenticated product, recommend public-to-product continuous onboarding as the first workflow.',
-        '',
-        'This default is not limited to B2B SaaS. Do not infer fit from the industry label alone, and do not manufacture pre-signup value or pressure. If the evidence is incomplete, ask only for the smallest missing fit fact. After project setup, route the accepted recommendation to `embedding-mcp-assistants`; the project-local playbook owns the two-surface design and exact implementation.',
-        '',
         '## Cold start (no project yet)',
         '',
         '1. New or empty directory: use `noodle-readiness.setup_project` with `mode: "initialize"`, or inline-execute the public fallback `noodle init --json`. This prepares the SaaS profile, installs pinned project-local tooling, and runs local checks. Preserve the existing package manager; use `install: false` / `--no-install` only for explicitly files-only work.',
@@ -55,8 +48,6 @@ function bootstrapRouterBody() {
         '3. Read the newly installed project-local `noodle-seed` `SKILL.md`, select its route for the requested outcome, and stop bootstrap discovery. This handoff is the bootstrap stop condition.',
         'Inspect `setup.ready`, `completed`, `failed`, `proof`, and `restartRequired`. A failed stage is not completion: repair that stage and retry the same public command without `--force`. Files-only output is unverified; local-synthetic proof never proves customer identity, backend writes, or hosted operation. Read the new context explicitly in an existing session; never launch a nested agent or claim it reloaded automatically.',
         '',
-        'After handoff, the project-local route decides which public command is needed. Continue to prefer typed `noodle-readiness` tools. If they remain unavailable, inline-execute that route’s exact public CLI arguments through the same packaged launcher. Do not invent a second lifecycle or bypass the project skill.',
-        '',
         'For authorized hosted work, preserve the canonical preflight, configuration, deployment, and readiness sequence. Follow every structured public `noodle ... --from-env` configuration action before resuming the same deploy. Linking and each configuration write remain separately authorized mutations. Show task-level progress and the exact target. On failure, report the structured error, safe public recovery commands, and resume command only.',
         '',
         '## Bootstrap boundary',

package/node_modules/@noodle-borg/agent-kit/dist/skill-authoring-split.js

@@ -0,0 +1,68 @@
+import { renderAuthoringWorkflowReference } from './skill-authoring-refs.js';
+const TOPIC_BY_HEADING = {
+    'Input paths': 'core',
+    'Fit check': 'core',
+    'Product-guide decision': 'core',
+    'Repair loop': 'core',
+    Connectors: 'connectors',
+    'HTTP connector example (full server)': 'connectors',
+    'Customer OAuth for remote MCP clients': 'authentication',
+    'Auth-derived customer API endpoints': 'authentication',
+    'Per-tool authorization': 'authentication',
+    'Delegated downstream auth (call your API as the signed-in user)': 'authentication',
+    'Design tools for the model': 'core',
+    'Invocation context': 'context',
+    'Ask for structured missing input': 'context',
+    'Compute connector example': 'connectors',
+    Tests: 'verification',
+    'Secrets and variables': 'authentication',
+    'Embedded assistant': 'managed',
+    'Managed capability reuse': 'managed',
+    'Knowledge components': 'managed',
+    'Managed collections': 'managed',
+    Boundaries: 'core',
+};
+export const AUTHORING_TOPIC_PATHS = [
+    'references/authoring-connectors.md',
+    'references/authoring-authentication.md',
+    'references/authoring-context.md',
+    'references/authoring-verification.md',
+    'references/authoring-managed.md',
+];
+/** The source is single-authored; each rendered reference is loaded only for its task. */
+export function renderAuthoringTopic(topic) {
+    const source = renderAuthoringWorkflowReference();
+    const sections = source.split(/(?=^## )/m);
+    const selected = sections.slice(1).filter((section) => {
+        const heading = /^## ([^\n]+)/.exec(section)?.[1];
+        if (heading === undefined)
+            throw new Error('authoring reference has no heading');
+        if (heading === 'Contents')
+            return false;
+        if (!(heading in TOPIC_BY_HEADING))
+            throw new Error(`unrouted authoring topic: ${heading}`);
+        return TOPIC_BY_HEADING[heading] === topic;
+    });
+    if (selected.length === 0)
+        throw new Error(`empty authoring topic: ${topic}`);
+    const contents = selected.map((section) => `- ${/^## ([^\n]+)/.exec(section)?.[1] ?? ''}`);
+    const intro = topic === 'core'
+        ? [
+            '# Authoring workflow',
+            '',
+            'Use this overview for Noodle authoring decisions. Open only the relevant topic:',
+            '- [Connectors and worked examples](./authoring-connectors.md)',
+            '- [Customer authentication and secrets](./authoring-authentication.md)',
+            '- [Invocation context and missing input](./authoring-context.md)',
+            '- [Verification](./authoring-verification.md)',
+            '- [Managed capabilities and collections](./authoring-managed.md)',
+            '',
+            '## Contents',
+            '',
+            ...contents,
+            '',
+        ].join('\n')
+        : `# Authoring: ${topic}\n\n## Contents\n\n${contents.join('\n')}\n\n`;
+    return `${intro}${selected.join('').trimEnd()}\n`;
+}
+//# sourceMappingURL=skill-authoring-split.js.map

package/node_modules/@noodle-borg/agent-kit/dist/skill-content.js

@@ -12,10 +12,11 @@ import { CLI_COMMANDS, COMPILE_ERROR_CODES, SDK_EXPORTS } from './generated/surf
 import { mdTable } from './md.js';
 import { renderAgentGuideReference } from './skill-agent-guide-ref.js';
 import { renderBuildAnMcpAppReference } from './skill-app-playbook-ref.js';
-import { renderAuthoringWorkflowReference, renderExamplesReference, renderWidgetsAndAppsReference, } from './skill-authoring-refs.js';
+import { renderExamplesReference, renderWidgetsAndAppsReference } from './skill-authoring-refs.js';
+import { renderAuthoringTopic } from './skill-authoring-split.js';
 import { renderConnectAnApiReference } from './skill-connect-refs.js';
 import { renderExperienceDesignReference } from './skill-design-refs.js';
-import { renderEmbeddedAssistantReference } from './skill-embedded-assistant-ref.js';
+import { renderEmbeddedAssistantTopic } from './skill-embedded-assistant-split.js';
 import { renderWrapExistingAppReference } from './skill-existing-app-ref.js';
 import { renderFeedbackReference } from './skill-feedback-ref.js';
 import { renderAppDirectoryComplianceReference, renderDeployAndOpsReference, renderInspectHostedReference, renderPublishingReference, renderTestInHostsReference, renderTroubleshootingReference, } from './skill-operations-refs.js';
@@ -409,9 +410,42 @@ export const SKILL_REFERENCES = [
     { relPath: 'references/agent-contract.md', render: renderAgentContractReference },
     { relPath: 'references/compile-errors.md', render: renderCompileErrorsReference },
     { relPath: 'references/build-an-mcp-server.md', render: renderBuildAnMcpServerReference },
-    { relPath: 'references/authoring-workflow.md', render: renderAuthoringWorkflowReference },
+    { relPath: 'references/authoring-workflow.md', render: () => renderAuthoringTopic('core') },
+    {
+        relPath: 'references/authoring-connectors.md',
+        render: () => renderAuthoringTopic('connectors'),
+    },
+    {
+        relPath: 'references/authoring-authentication.md',
+        render: () => renderAuthoringTopic('authentication'),
+    },
+    { relPath: 'references/authoring-context.md', render: () => renderAuthoringTopic('context') },
+    {
+        relPath: 'references/authoring-verification.md',
+        render: () => renderAuthoringTopic('verification'),
+    },
+    { relPath: 'references/authoring-managed.md', render: () => renderAuthoringTopic('managed') },
     { relPath: 'references/tool-design.md', render: renderToolDesignReference },
-    { relPath: 'references/embedded-assistant.md', render: renderEmbeddedAssistantReference },
+    {
+        relPath: 'references/embedded-assistant.md',
+        render: () => renderEmbeddedAssistantTopic('core'),
+    },
+    {
+        relPath: 'references/embedded-assistant-messaging.md',
+        render: () => renderEmbeddedAssistantTopic('messaging'),
+    },
+    {
+        relPath: 'references/embedded-assistant-identity.md',
+        render: () => renderEmbeddedAssistantTopic('identity'),
+    },
+    {
+        relPath: 'references/embedded-assistant-rendering.md',
+        render: () => renderEmbeddedAssistantTopic('rendering'),
+    },
+    {
+        relPath: 'references/embedded-assistant-operations.md',
+        render: () => renderEmbeddedAssistantTopic('operations'),
+    },
     { relPath: 'references/connect-an-api.md', render: renderConnectAnApiReference },
     { relPath: 'references/wrap-existing-app.md', render: renderWrapExistingAppReference },
     { relPath: 'references/build-an-mcp-app.md', render: renderBuildAnMcpAppReference },

package/node_modules/@noodle-borg/agent-kit/dist/skill-embedded-assistant-ref.js

@@ -57,7 +57,7 @@ export function renderEmbeddedAssistantReference() {
         '| Owner | Values | Destination |',
         '| --- | --- | --- |',
         '| Noodle operator | Login, selected org/app/env | Plugin-managed CLI profile and explicit target; never the SaaS runtime |',
-        '| Noodle-managed model | No authored provider, model id, URL, or key | Hosted operator state; available only when Noodle has enrolled the exact org/app/env |',
+        '| Noodle-managed model | No authored provider, model id, URL, or key | Hosted operator state; billing-attributed targets are eligible for the bounded sponsored beta |',
         '| Operator-provided model | `ASSISTANT_MODEL_BASE_URL`, `ASSISTANT_MODEL`, `ASSISTANT_MODEL_API_KEY` | `noodle variables set` / `noodle secrets set`; never the SaaS environment |',
         '| Connector/delegated exchange | Connector credentials and any customer-owned token-exchange client | Noodle managed configuration plus the matching customer backend secret manager |',
         '| SaaS backend | `NOODLE_SERVICE_URL`, `NOODLE_ASSISTANT_CLIENT_ID`, `NOODLE_ASSISTANT_CLIENT_SECRET`, `PUBLIC_APP_ORIGIN` | Backend-only environment or secret manager; never browser code or public-prefixed variables |',
@@ -65,7 +65,7 @@ export function renderEmbeddedAssistantReference() {
         '',
         '## Select the architecture before code',
         '',
-        'Do not edit either codebase until one architecture brief is decision-complete. Name the external end user, the conversational job, one to three workflows, the exact access mode, renderer, existing host framework, identity/session boundary, server-owned routing authority, model owner, exact origin and mount point, and requested evidence level.',
+        'Establish the user, job, access mode, identity/session boundary, server-owned routing, model owner, and relevant origins before changing those trust boundaries. Record consequential choices proportionally; continue independent local work while a missing fact is clarified.',
         '',
         'If the external user, job, or workflow set is still vague, hand off to `designing-mcp-products` before code. Preserve its bounded product outcome and resume this workflow only when the value path and one representative success path are explicit.',
         '',
@@ -88,7 +88,7 @@ export function renderEmbeddedAssistantReference() {
         '',
         'Use the existing host framework and its package manager. Recommend the managed renderer unless the product names a concrete UI or integration benefit that requires the headless client; a custom renderer accepts the complete transcript-part obligation described below. Recommend `noodleManaged()` when Noodle owns the managed-cloud model for the exact eligible target; recommend `openAICompatible(...)` only when the operator or self-hosted deployment owns that model endpoint and credentials. Never present both as unfinished choices.',
         '',
-        'The architecture brief must state the selected topology, why it fits the named user and job, the two code owners and two local processes, credential and identity flow, routing authority, model owner, files expected to change, and the first requested evidence boundary. If identity/session ownership, exact origin, tenant-routing authority, model ownership, or evidence target is unavailable, return a blocked architecture brief naming the missing owner or decision and do not edit either codebase.',
+        'Explain the selected topology and its identity, credential, routing, and model boundaries in the form useful for the task. If a fact needed for a security-sensitive edit is missing, ask for that fact and continue any independent work.',
         '',
         '### First-workflow default: continuous onboarding',
         '',
@@ -141,7 +141,7 @@ export function renderEmbeddedAssistantReference() {
         '}),',
         '```',
         '',
-        '`noodleManaged()` is the zero-configuration Cloud path: the public artifact contains only `{ kind: "noodle-managed" }`. It never exposes a provider or model identifier, and it fails closed unless Noodle has enrolled that exact deployment target. For a customer- or self-hosted model, replace it with `openAICompatible({ baseUrl: variable("ASSISTANT_MODEL_BASE_URL"), model: variable("ASSISTANT_MODEL"), apiKey: secret("ASSISTANT_MODEL_API_KEY"), transport: "responses" })` when the endpoint implements Responses. Omit `transport` or use `"chat-completions"` for Chat Completions. Noodle calls only the selected transport and never probes or falls back to the other endpoint.',
+        '`noodleManaged()` is the zero-configuration Cloud path: the public artifact contains only `{ kind: "noodle-managed" }`. It never exposes a provider or model identifier. Billing-attributed targets are eligible for the bounded sponsored beta; missing billing attribution or hosted protection fails closed. For a customer- or self-hosted model, replace it with `openAICompatible({ baseUrl: variable("ASSISTANT_MODEL_BASE_URL"), model: variable("ASSISTANT_MODEL"), apiKey: secret("ASSISTANT_MODEL_API_KEY"), transport: "responses" })` when the endpoint implements Responses. Omit `transport` or use `"chat-completions"` for Chat Completions. Noodle calls only the selected transport and never probes or falls back to the other endpoint.',
         '',
         'Origins are exact: scheme, host, and optional port, with no path, trailing slash, or wildcard. Production origins must be HTTPS; plain HTTP is accepted only for loopback development origins (`http://localhost:<port>`, `http://127.0.0.1:<port>`). `noodle dev` serves the MCP project, not the embedding SaaS. For a public surface it also prints a process-local Embed ID and script; mount that script on the separately running loopback website to test anonymous mint, chat, widgets, and confirmation. The local ID is ephemeral, while a hosted deploy provisions the stable ID behind durable admission counters.',
         '',

package/node_modules/@noodle-borg/agent-kit/dist/skill-embedded-assistant-split.js

@@ -0,0 +1,68 @@
+import { renderEmbeddedAssistantReference } from './skill-embedded-assistant-ref.js';
+const TOPIC_BY_HEADING = {
+    'Public messaging: WhatsApp, Instagram DMs and SMS': 'messaging',
+    'Collect interactions': 'messaging',
+    Architecture: 'core',
+    'Select the architecture before code': 'core',
+    'Install into the existing application': 'core',
+    'Author and validate': 'core',
+    'Product workflow guidance': 'core',
+    'Customize the presentation': 'rendering',
+    'Configure and deploy': 'operations',
+    'Access modes and customer auth': 'identity',
+    'Create the backend client': 'identity',
+    'Integrate the customer backend': 'identity',
+    'Ground time and ambient facts': 'identity',
+    'Structured missing input': 'identity',
+    'Verified session context (identity and claims)': 'identity',
+    'The session response': 'identity',
+    'Mount a public website surface': 'rendering',
+    'Choose a browser renderer': 'rendering',
+    'Host readiness and promotion': 'operations',
+    'Launch and qualified-usage proof': 'operations',
+    'Toolchain requirements': 'operations',
+    'Verify the boundary': 'operations',
+    'Troubleshooting: symptom to diagnosis': 'operations',
+};
+/** Keep the authored reference single-sourced while loading only the requested topic in an agent. */
+export function renderEmbeddedAssistantTopic(topic) {
+    const source = renderEmbeddedAssistantReference();
+    const sections = source.split(/(?=^## )/m);
+    const selected = sections.slice(1).filter((section) => {
+        const heading = /^## ([^\n]+)/.exec(section)?.[1];
+        if (heading === undefined)
+            throw new Error('embedded assistant reference has no heading');
+        if (heading === 'Contents')
+            return false;
+        if (!(heading in TOPIC_BY_HEADING)) {
+            throw new Error(`unrouted embedded assistant topic: ${heading}`);
+        }
+        return TOPIC_BY_HEADING[heading] === topic;
+    });
+    if (selected.length === 0)
+        throw new Error(`empty embedded assistant topic: ${topic}`);
+    const contents = selected.map((section) => {
+        const heading = /^## ([^\n]+)/.exec(section)?.[1];
+        if (heading === undefined)
+            throw new Error('embedded assistant section has no heading');
+        return `- ${heading}`;
+    });
+    const intro = topic === 'core'
+        ? [
+            '# Embedded assistant',
+            '',
+            'Read this overview for architecture and authoring. Load only the topic needed next:',
+            '- [Messaging and collection](./embedded-assistant-messaging.md)',
+            '- [Identity and backend sessions](./embedded-assistant-identity.md)',
+            '- [Appearance and browser rendering](./embedded-assistant-rendering.md)',
+            '- [Deployment, verification and recovery](./embedded-assistant-operations.md)',
+            '',
+            '## Contents',
+            '',
+            ...contents,
+            '',
+        ].join('\n')
+        : `# Embedded assistant: ${topic}\n\n## Contents\n\n${contents.join('\n')}\n\n`;
+    return `${intro}${selected.join('').trimEnd()}\n`;
+}
+//# sourceMappingURL=skill-embedded-assistant-split.js.map

package/node_modules/@noodle-borg/agent-kit/dist/skill-existing-app-ref.js

@@ -42,7 +42,7 @@ export function renderWrapExistingAppReference() {
         '6. **Reject unstable seams.** Do not call an unstable server-call protocol whose identifier or serialization changes across builds. Never use direct database access, including ORM or SQL; it bypasses application authorization and business rules. Do not log in and copy a browser session into the runtime; copying a browser session or its credentials into the runtime is prohibited. Do not treat a service credential as per-user authorization. Propose a narrow application-owned HTTP handler instead.',
         '7. **Separate implementation ownership.** Produce an existing-application phase for handlers/auth/tests, a Noodle-project phase for TypeScript connector/tools/fakes/tests, and a cross-surface verification phase. If repositories differ, create separate repository-scoped plans and approval boundaries.',
         '8. **Present and stop.** Show the capability map, identity/routing decision, minimum honest application changes, rejected alternatives, test matrix, risks, and phases in the conversation. A design approval is review only. Local implementation requires an explicit “proceed” for the named repository. Local implementation approval does not authorize hosted configuration, live writes, deployment, publication, or issue-state changes; those require their own authority.',
-        '9. **Hand off approved work.** Once a decision-complete local plan is explicitly authorized, persist it when repository workflow requires and hand it to `executing-noodle-plans`. Use the existing server-authoring and API-connection playbooks for implementation and real-output evidence; do not add another task loop here.',
+        '9. **Continue approved work.** After the user authorizes the implementation, follow the repository workflow and the relevant Noodle authoring or API-connection skill. Verify real output without reopening settled decisions.',
         '',
         '## Verification evidence',
         '',

package/node_modules/@noodle-borg/agent-kit/dist/skill-router.d.ts

@@ -1,6 +1,6 @@
-import { type BehaviorSkillName } from './behavior-skills.js';
+import type { BehaviorSkillName } from './behavior-skills.js';
 import type { AgentTarget } from './index.js';
-export declare const SKILL_DESCRIPTION: string;
+export declare const SKILL_DESCRIPTION = "Build or operate a Noodle Seed MCP server or app with TypeScript and the noodle CLI. Use for Noodle project setup, an unclear Noodle workflow, or finding the relevant specialist skill.";
 export type SkillReferencePath = `references/${string}.md`;
 export declare const APP_DIRECTORY_COMPLIANCE_REFERENCE: SkillReferencePath;
 type SkillRouteId = 'design-product' | 'create-product-guide' | 'wrap-existing-app' | 'build-server' | 'connect-api' | 'build-app' | 'verify-recover' | 'debug-recover' | 'inspect-hosted' | 'deploy-hosted' | 'embed-assistant' | 'publish' | 'feedback';
@@ -11,6 +11,7 @@ export interface SkillRoute {
     readonly exitCondition: string;
 }
 export declare const SKILL_ROUTES: readonly SkillRoute[];
+/** A short index for ambiguous requests; installed specialist skills are directly discoverable. */
 export declare function skillRouterBody(_target: AgentTarget): string;
 export {};
 //# sourceMappingURL=skill-router.d.ts.map

package/node_modules/@noodle-borg/agent-kit/dist/skill-router.js

@@ -1,15 +1,12 @@
 // Intent router for the project-local `noodle-seed` skill. Keep this file small: it selects one
 // outcome workflow and bounds progressive disclosure. Detailed MCP guidance belongs in the
 // one-level reference tree rendered by skill-content.ts.
-import { BEHAVIOR_SKILLS } from './behavior-skills.js';
-export const SKILL_DESCRIPTION = 'Use when building, validating, testing, deploying, or operating a local or hosted Noodle Seed ' +
-    'MCP server or app authored in TypeScript with the noodle CLI, or improving signup or onboarding ' +
-    'conversion or selecting a first Noodle workflow for an account-growth product.';
+export const SKILL_DESCRIPTION = 'Build or operate a Noodle Seed MCP server or app with TypeScript and the noodle CLI. Use for Noodle project setup, an unclear Noodle workflow, or finding the relevant specialist skill.';
 export const APP_DIRECTORY_COMPLIANCE_REFERENCE = 'references/app-directory-compliance.md';
 export const SKILL_ROUTES = [
     {
         id: 'design-product',
-        intent: 'Turn a vague MCP product idea into a bounded design before implementation',
+        intent: 'Choose a first Noodle workflow or turn a vague MCP idea into a bounded design',
         skill: 'designing-mcp-products',
         exitCondition: 'The product contract identifies the user benefit, model boundary, evidence, and next implementation skill.',
     },
@@ -86,110 +83,25 @@ export const SKILL_ROUTES = [
         exitCondition: 'A sanitized dry-run preview and exact proposal are shown, then one submission occurs only after explicit approval.',
     },
 ];
-/** Complete lookup catalog. Routes above, not this inventory, own discovery. */
-const REFERENCE_INDEX_LINES = [
-    '- `references/agent-contract.md` — the `--json` envelope, exit codes, and the three output modes.',
-    '- `references/product-agent-guides.md` — decide, interview, propose, prove, preview, and explicitly install one host-neutral product guide.',
-    '- `references/sdk-surface.md` — what to import from `@noodleseed/one` and which builder to use.',
-    '- `references/cli-commands.md` — every `noodle` command, grouped by area.',
-    '- `references/compile-errors.md` — fix `noodle validate` errors by code.',
-    '- `references/build-an-mcp-server.md` — outcome-first workflow for a focused, tested, model-facing MCP product.',
-    '- `references/authoring-workflow.md` — input paths, fit checks, connector patterns, authentication, invocation context, testing, and managed config.',
-    '- `references/tool-design.md` — intent-shaped tools, titles and annotations, bounded outputs, tool-surface budget, and context provisioning.',
-    '- `references/embedded-assistant.md` — HTTPS origins, managed model config, deploy sequencing, session exchange, browser mounting, and credential boundaries.',
-    '- `references/connect-an-api.md` — secure credentials, probe the live API, model the observed shape, and prove real output.',
-    '- `references/wrap-existing-app.md` — read-only identity-first planning for an existing application with no stable usable API.',
-    '- `references/build-an-mcp-app.md` — product-fit, output-boundary, fallback, and evidence workflow for an MCP App.',
-    '- `references/experience-design.md` — design an app experience: funnel boundary, grounding, two users, display modes, and wireframe.',
-    '- `references/widgets-and-apps.md` — MCP Apps, typed views, widget hooks, output shaping, and CSP.',
-    '- `references/test-in-hosts.md` — connect and test in real MCP hosts and protocol inspection clients.',
-    '- `references/verify-and-recover.md` — ordered evidence ladder, bounded repair, and honest completion claims.',
-    '- `references/troubleshooting.md` — runtime symptom to cause and fix, locally and hosted.',
-    '- `references/inspect-hosted.md` — read-only hosted status, logs, metrics, events, and deployment diagnosis.',
-    '- `references/deploy-and-ops.md` — explicitly authorized hosted link, config, deploy, access, connection writes, and rollback.',
-    '- `references/publishing.md` — prepare and submit to app and connector directories.',
-    `- \`${APP_DIRECTORY_COMPLIANCE_REFERENCE}\` — the pre-submission experience and policy checklist.`,
-    '- `references/examples.md` — flagship example index and a canonical `server.ts`.',
-    '- `references/feedback.md` — draft sanitized product feedback and submit only with user approval.',
-];
-function routeTableLines() {
-    return [
-        '| User outcome | Load sibling skill | Canonical playbook | Done when |',
-        '| :--- | :--- | :--- | :--- |',
-        ...SKILL_ROUTES.map((route) => {
-            const skill = BEHAVIOR_SKILLS.find((candidate) => candidate.name === route.skill);
-            if (skill === undefined)
-                throw new Error(`missing behavior skill for route ${route.id}`);
-            const supporting = skill.supportingReferences.length > 0
-                ? skill.supportingReferences.map((reference) => `\`${reference}\``).join(', ')
-                : 'None';
-            return `| ${route.intent} | \`${route.skill}\` | \`${skill.primaryReference}\` (${supporting}) | ${route.exitCondition} |`;
-        }),
-    ];
-}
+/** A short index for ambiguous requests; installed specialist skills are directly discoverable. */
 export function skillRouterBody(_target) {
-    const preamble = 'Use this skill for project-local Noodle Seed authoring in the active coding host; preserve generated and user instruction boundaries.';
     return [
         '# Noodle Seed',
         '',
-        'Build, validate, test, deploy, and operate Noodle Seed MCP servers and apps authored in TypeScript with the `noodle` CLI. Author from the configured entrypoint (usually `server.ts`); keep the authoring surface TypeScript-only.',
-        '',
-        preamble,
-        '',
-        "If the request is unrelated to the Noodle MCP surface, stop here: follow the project's normal instructions and run no Noodle lifecycle commands.",
-        '',
-        '**Installed-plugin execution.** When this skill is supplied by the Noodle Developer plugin, you write and test the application source, then use its supported `noodle-readiness` tools for project setup, build gates, exact-target linking, variables, secret-from-environment transfer, gated deployment, and feedback. Treat the corresponding public `noodle ...` command as recovery text, never as permission to discover or expose an internal launcher. If a tool fails, report its structured error and public `noodle ...` command; do not ask the user to copy a private installation path or perform an operation the authorized tool can perform.',
-        '',
-        '## Route the request',
-        '',
-        'Choose exactly one primary route from the user outcome below, then load the selected sibling skill and hand off the request. Read that primary reference in full; read supporting references only when the sibling or observed evidence requires them. Do not reread the corpus or restart discovery after the handoff.',
-        '',
-        'Apply this precedence when wording overlaps: concrete failure evidence takes the debugging route; an explicit request to create, revise, regenerate, or recover an app product skill takes `creating-product-agent-guides`; an MCP App/UI outcome takes the App route; an existing application with no stable, usable API or specification takes `wrapping-existing-applications`; only when all four API-evidence inputs exist—an API base URL, authentication scheme, representative safe read, and observed response—use `connecting-apis-to-mcp`; missing, stale, inaccessible, undocumented-only, or otherwise unusable evidence remains in `wrapping-existing-applications`; both integration routes take precedence over generic server building; hosted inspection is debugging read-only; hosted mutation requires the explicitly requested deployment route.',
-        '',
-        'Negative routing examples: “Inspect hosted logs/status” → `inspect-hosted` (read-only). “Prepare for deployment” → the applicable build or verification route; with existing access it may inspect `deploy preflight`, then stop with a handoff. Preparation does not authorize `link`, hosted config, publication, rollback, host writes, or submission. “Keep this local” → a build or verification route, never a hosted route.',
-        '',
-        '## First-workflow heuristic',
-        '',
-        'When the user asks what to build first or gives only a broad growth goal, inspect the repository and product context before asking them to invent a workflow. Do not classify the business or choose a design from an industry label alone.',
-        '',
-        'If the evidence shows a public visitor surface, an existing signup or sign-in boundary, a useful pre-account result the assistant can genuinely produce, and a meaningful authenticated outcome inside the product—and more authenticated users are valuable—recommend public-to-product continuous onboarding and route to `embedding-mcp-assistants`. This recommendation is not limited to B2B SaaS. If one of those facts is unclear, ask only for the smallest missing fit fact; if the pattern does not fit, route by the user’s actual outcome instead.',
-        '',
-        ...routeTableLines(),
-        '',
-        '## Common machine loop',
-        '',
-        'Every `--json` command speaks the canonical envelope on stdout. Parse machine state instead of scraping human prose; `references/agent-contract.md` owns the envelope, streaming records, and exit codes.',
-        '',
-        'Inside the installed plugin, perform mapped steps with `noodle-readiness` tools and use the public `noodle ...` spelling only when reporting the logical action or a fallback. Outside the plugin, run the public CLI directly. Never construct a hidden launcher command.',
-        '',
-        "1. **Discover** — use `noodle commands --json` when the required command or flags are uncertain; don't read CLI source.",
-        '2. **Author** — for build routes, edit the configured TypeScript entrypoint, usually `src/server.ts`.',
-        '3. **Validate** — run `noodle validate --json`; repair each `error.errors[]` item at its `path`, then re-run `noodle validate --json`.',
-        '4. **Smoke** — run `noodle test --json` after validation passes.',
-        '5. **Prove the requested level** — connector routes require a safe live read with `noodle tools call`; App routes require `noodle check --json` and `noodle devtools`; hosted or host actions run only when the selected route and current user request authorize that exact level.',
-        '6. **Report evidence** — claim only the highest level actually exercised and name anything not run.',
-        '',
-        '## Reference lookup catalog',
-        '',
-        'This is a lookup catalog, not a discovery checklist. Return here only when the selected primary route names a missing technical detail:',
-        '',
-        ...REFERENCE_INDEX_LINES,
+        'Author Noodle Seed MCP servers and apps in TypeScript. The compiler owns manifests and runtime artifacts. If the request is unrelated to this Noodle project, follow the project instructions without running Noodle lifecycle commands.',
         '',
-        '## Product feedback',
+        '## Find the relevant skill',
         '',
-        'When you discover a bug, missing capability, misleading doc, or improvement idea, draft and sanitize one finding, then preview it with `noodle-readiness.preview_product_feedback` in the installed plugin or `noodle feedback ... --dry-run --json` in the public CLI. Inspect and show the normalized submission, diagnostics, and private destination. Ask for explicit approval of that exact proposal; do not submit it until approval. Then call `noodle-readiness.submit_product_feedback` once with approval, or run the public CLI once without `--dry-run`. Follow `references/feedback.md`; pass structured arguments directly instead of composing a shell command, never include customer code, secrets, personal data, or identifying project details, and never auto-login or retry-loop.',
+        'Use a specialist skill directly when the task is clear. For an ambiguous Noodle request, use this index; a task may need more than one skill as work progresses.',
+        ...SKILL_ROUTES.map((route) => `- ${route.intent}: \`${route.skill}\``),
         '',
-        '## Safety',
+        'For a concrete failure, start with `debugging-mcp-delivery`. For hosted status or logs, inspect read-only. Deployment, configuration writes, rollback, and directory submission require an authorized target and action. API connection needs a usable API origin, auth scheme, safe read, and observed result; when those are missing, inspect the application and establish them before promising a live integration.',
         '',
-        '- Keep secrets, bearer tokens, refresh tokens, static access keys, `.env` / `.env.noodle` values, and `~/.noodle/config.json` out of prompts, logs, docs, tests, and generated files.',
-        '- Never expose an internal launcher or private installation path, ask the user to paste a command the plugin can execute, or use an ad hoc shell/file-parsing pipeline to move a secret. Use the typed secret-from-environment tool or `noodle secrets set ... --from-env NAME`.',
-        '- Do not hand-author manifest JSON/YAML, runtime artifacts, connector IR, or hosted asset metadata.',
-        '- Do not add static data-plane credential paths; hosted access is identity-based.',
-        '- Hosted mutation is opt-in. Run `link`, hosted secret/variable/config/access changes, deploy, rollback, host configuration writes, or directory submission only when the current user request explicitly authorizes the exact mutation and target. An inspect, prepare, validate, test, or local-only request grants no such authority; stop and ask before crossing that boundary.',
+        '## Find current product facts',
         '',
-        '## Customization',
+        'Use [the SDK reference](./references/sdk-surface.md) for TypeScript builders, [the CLI reference](./references/cli-commands.md) or `noodle commands --json` for commands, and [the machine response contract](./references/agent-contract.md) when parsing errors. Read only the reference relevant to the task. Validate authored changes with `noodle validate --json`, then run the relevant local behavior check. A connector-backed capability also needs a representative safe live read before claiming its response mapping works.',
         '',
-        'This skill is regenerated by `noodle agents setup --write`. For project-specific standards, create a separate skill; do not edit this file or its references.',
+        'In the installed Noodle Developer plugin, use supported `noodle-readiness` tools for lifecycle operations; report public `noodle ...` commands for recovery. Outside the plugin, run the public CLI. Keep credentials and internal launcher paths out of prompts and output. Transfer secrets only through supported from-environment operations. Hosted changes need the user-authorized target and action; local checks do not prove hosted behavior.',
     ].join('\n');
 }
 //# sourceMappingURL=skill-router.js.map

package/node_modules/@noodle-borg/agent-kit/dist/skill-server-playbook-ref.js

@@ -50,7 +50,7 @@ export function renderBuildAnMcpServerReference() {
         '- Tool registers but returns empty or `undefined` fields: inspect one sanitized real response, correct `${response...}` mappings, and rerun the same read.',
         '- Credential unavailable: verify `secret(...)` naming and the effective local target; never inline or print the secret.',
         '- Missing product input: ask for the smallest concrete example, schema, or rule that unblocks the selected job. Do not widen the build to compensate.',
-        '- Repeated failure at the same layer: stop after two evidence-backed repair attempts with the same failure signature and report the command, sanitized error, evidence already proven, and exact next action.',
+        '- Repeated failure at the same layer: continue only with a new evidence-backed cause; otherwise preserve the sanitized error and passing evidence, then report the blocker and exact next action.',
         '',
         '## Stop conditions',
         '',

package/node_modules/@noodle-borg/agent-kit/dist/skill-verification-ref.js

@@ -42,7 +42,7 @@ export function renderVerifyAndRecoverReference() {
         '3. Form one evidence-backed cause from the observed output. If the two canonical supports do not cover it, select one matching symptom from the router lookup catalog; do not scan every recovery path.',
         '4. Make the smallest in-scope repair. Do not freeform re-edit adjacent code, change credentials, redeploy, or add product behavior without evidence and authority.',
         '5. Rerun only the same evidence layer that failed. Once it passes, continue upward only to the user-requested level.',
-        '6. Stop after two evidence-backed repair attempts with the same failure signature, or immediately when the next action requires new authority or external state.',
+        '6. If the same failure persists without a new evidence-backed cause, preserve the repro and report the blocker. Stop when the next action requires new authority or external state.',
         '',
         '## Verification evidence',
         '',
@@ -69,7 +69,7 @@ export function renderVerifyAndRecoverReference() {
         '',
         '- Stop complete when the user-requested evidence level and every dependency below it pass in the current target.',
         '- Stop blocked when progress requires credentials, approval, host access, deployment authority, production access, or an external-state change not available in scope.',
-        '- Stop after two evidence-backed repair attempts with the same failure signature at one layer; do not hide repetition behind unrelated edits.',
+        '- Stop when the same failure has no new evidence-backed repair; do not hide repetition behind unrelated edits.',
         '- Never claim fixed or working without rerunning the failed layer, and never upgrade compile, local, deployment, or stale historical evidence into a stronger claim.',
     ].join('\n');
 }

package/node_modules/@noodle-borg/agent-kit/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noodle-borg/agent-kit",
-  "version": "0.112.0",
+  "version": "0.113.0",
   "license": "Apache-2.0",
   "type": "module",
   "engines": {

package/node_modules/@noodle-borg/assistant-gateway/package.json

@@ -42,7 +42,7 @@
     "@noodle-borg/module-audit": "0.0.0",
     "@noodle-borg/protocol": "0.0.0",
     "@noodle-borg/runtime": "0.0.0",
-    "@noodleseed/assistant": "1.38.0",
+    "@noodleseed/assistant": "1.39.0",
     "zod": "^4.4.3"
   },
   "devDependencies": {

package/node_modules/@noodle-borg/service/package.json

@@ -41,7 +41,7 @@
     "@noodle-borg/managed-capabilities": "0.0.0",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@noodle-borg/admission-limits": "0.0.0",
-    "@noodle-borg/agent-kit": "0.112.0",
+    "@noodle-borg/agent-kit": "0.113.0",
     "@noodle-borg/app-package": "0.0.0",
     "@noodle-borg/assistant-gateway": "0.0.0",
     "@noodle-borg/auth": "0.0.0",

package/node_modules/@noodle-borg/transport-http/dist/handler.js

@@ -124,6 +124,9 @@ export function createMcpRouter(lookup, options = {}) {
                 ...(route?.kind === 'tenant' && route.publicResourceUrl !== undefined
                     ? { publicResourceUrl: route.publicResourceUrl }
                     : {}),
+                ...(route?.kind === 'tenant' && route.clientAddress !== undefined
+                    ? { clientAddress: route.clientAddress }
+                    : {}),
             }, routeId, maxBody, options.allowedOrigins, tenant);
         })()).then(() => logRequest(logger, logId, req, res, start));
     };

package/node_modules/@noodle-borg/transport-http/dist/routing.d.ts

@@ -10,6 +10,8 @@ type ParsedRoute = {
     readonly ref: TenantRouteRef;
     readonly logId: string;
     readonly publicResourceUrl?: string;
+    /** The caller address the edge Worker observed; present only on edge-authenticated routes. */
+    readonly clientAddress?: string;
 } | {
     readonly kind: 'deployment';
     readonly deploymentId: string;

package/node_modules/@noodle-borg/transport-http/dist/routing.js

@@ -15,6 +15,7 @@ export async function resolveRoute(req, pathname, publicTenantRouting) {
         const ref = await publicTenantRouting.resolveTenant(publicRef);
         if (ref === undefined)
             return { ok: true, route: null };
+        const clientAddress = header(req, 'x-noodle-client-address');
         return {
             ok: true,
             route: {
@@ -22,6 +23,7 @@ export async function resolveRoute(req, pathname, publicTenantRouting) {
                 ref,
                 logId: tenantLogId(ref),
                 publicResourceUrl: canonicalPublicResourceUrl(forwardedHost),
+                ...(clientAddress !== undefined ? { clientAddress } : {}),
             },
         };
     }

package/node_modules/@noodle-borg/transport-http/dist/serve-request.js

@@ -1,5 +1,5 @@
 import { randomUUID } from 'node:crypto';
-import { trustedPublicAdmission } from '@noodle-borg/admission-limits/portable';
+import { clientAddressBucket, trustedPublicAdmission, } from '@noodle-borg/admission-limits/portable';
 import { createDualEraMcpHandler, handleStatelessHttp, JSON_RPC, } from '@noodle-borg/protocol';
 import { admissionContexts, requestsInvocationContext } from './admission-context.js';
 import { authorizeIdentityMode, authorizeMixedMode, authorizePublicServiceMode, canonicalResourceUrl, isIdentityMode, } from './identity-authorization.js';
@@ -134,6 +134,7 @@ export async function serveRequest(req, res, target, auth, routeId, maxBody, all
         ...(auth.accessMode !== undefined ? { accessMode: auth.accessMode } : {}),
         ...(req.socket.remoteAddress !== undefined ? { remoteAddress: req.socket.remoteAddress } : {}),
     });
+    const callerNetwork = clientAddressBucket(auth.clientAddress);
     for (const context of contexts) {
         const decision = auth.admissionGate
             ? await auth.admissionGate(context)
@@ -148,6 +149,7 @@ export async function serveRequest(req, res, target, auth, routeId, maxBody, all
             ...(context.env !== undefined ? { env: context.env } : {}),
             ...(context.serverVersion !== undefined ? { serverVersion: context.serverVersion } : {}),
             ...(context.accessMode !== undefined ? { accessMode: context.accessMode } : {}),
+            ...(callerNetwork !== undefined ? { callerNetwork } : {}),
             decision: decision.allow ? 'allow' : 'deny',
             ...(decision.reason !== undefined ? { reason: decision.reason } : {}),
         });

package/node_modules/@noodleseed/assistant/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noodleseed/assistant",
-  "version": "1.38.0",
+  "version": "1.39.0",
   "description": "Embed the Noodle Seed customer-branded assistant in your web app with managed or framework-owned UI, a framework-neutral MCP App host, a DOM-free client, and a backend session helper. Authoring and deploying the server is @noodleseed/one.",
   "license": "Apache-2.0",
   "repository": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@noodleseed/one",
-  "version": "0.188.0",
+  "version": "0.190.0",
   "private": false,
   "description": "Noodle CLI by Noodle Seed — author, run, and deploy declarative MCP servers. Embedding the assistant in your own web app is @noodleseed/assistant.",
   "license": "Apache-2.0",
@@ -236,7 +236,7 @@
     "@modelcontextprotocol/client": "2.0.0",
     "@modelcontextprotocol/server": "2.0.0",
     "@noodle-borg/admission-limits": "0.0.0",
-    "@noodle-borg/agent-kit": "0.112.0",
+    "@noodle-borg/agent-kit": "0.113.0",
     "@noodle-borg/app-audit": "0.0.0",
     "@noodle-borg/app-package": "0.0.0",
     "@noodle-borg/assistant-gateway": "0.0.0",

package/node_modules/@noodle-borg/agent-kit/dist/plan-execution-skill.d.ts

@@ -1,10 +0,0 @@
-import type { AgentTarget } from './skill-registry.js';
-export declare const EXECUTING_NOODLE_PLANS_SKILL: {
-    readonly name: "executing-noodle-plans";
-    readonly description: "Use when the user asks to execute an approved, decision-complete implementation plan for a Noodle Seed project task by task with test-first changes, review, recovery, and final verification.";
-    readonly supportedHosts: readonly ["codex", "claude-code"];
-    readonly files: readonly [];
-    readonly renderBody: typeof renderExecutingNoodlePlansSkill;
-};
-export declare function renderExecutingNoodlePlansSkill(_target?: AgentTarget): string;
-//# sourceMappingURL=plan-execution-skill.d.ts.map

package/node_modules/@noodle-borg/agent-kit/dist/plan-execution-skill.js

@@ -1,56 +0,0 @@
-export const EXECUTING_NOODLE_PLANS_SKILL = {
-    name: 'executing-noodle-plans',
-    description: 'Use when the user asks to execute an approved, decision-complete implementation plan for a Noodle Seed project task by task with test-first changes, review, recovery, and final verification.',
-    supportedHosts: ['codex', 'claude-code'],
-    files: [],
-    renderBody: renderExecutingNoodlePlansSkill,
-};
-export function renderExecutingNoodlePlansSkill(_target) {
-    return [
-        '# Execute a Noodle Seed implementation plan',
-        '',
-        'Execute an approved plan without reopening settled design decisions. Keep implementation, review, and evidence scoped to the current repository and the authority the user granted.',
-        '',
-        '## Preconditions',
-        '',
-        '- Read the plan, repository instructions, current branch status, and the files named by the first incomplete task.',
-        '- Confirm the plan is decision-complete, test-first, compatible with the current code, and explicit about public contracts and required verification.',
-        '- Work in the repository-required isolated branch or worktree and preserve unrelated changes.',
-        '- If current code invalidates the plan or two requirements conflict, stop before editing and ask which requirement governs.',
-        '',
-        '## Task loop',
-        '',
-        'Execute one task at a time in plan order:',
-        '',
-        '1. Restate the task boundary, expected behavior, focused failing test, and files in scope.',
-        '2. Add or update the focused test first and run it to confirm the expected failure when practical.',
-        '3. Implement only the behavior required to make that test pass. Do not add compatibility paths, abstractions, or adjacent cleanup the plan did not require.',
-        '4. Run the focused test, then the package-level checks named by the plan.',
-        '5. Review the task diff for plan compliance, correctness, security, type safety, and unnecessary surface area.',
-        '6. Record completion in the plan checkbox when it is writable and in a focused conventional commit.',
-        '',
-        'When the active host provides isolated task workers and user authorization permits delegation, use a fresh implementer for an independent task and a separate reviewer after it. Give each worker only the task requirements, binding global constraints, file paths, and required evidence. Never run workers in parallel when their files or contracts overlap. Execute inline when workers are unavailable, tasks are tightly coupled, or delegation is not authorized.',
-        '',
-        '## Review and recovery',
-        '',
-        '- Independent review must compare the task requirements with the exact task diff and test evidence; implementer self-review does not replace it when a reviewer is available.',
-        '- Return concrete findings to the implementer, rerun the tests that cover each correction, and review the correction diff again.',
-        '- Allow at most three correction rounds for the same finding. Then stop with the unresolved requirement, attempted fixes, and current evidence instead of silently accepting drift.',
-        '- On context loss or interruption, resume from the plan checkboxes, git status, and git log; verify the last completed task before starting the first incomplete one.',
-        '',
-        '## Completion',
-        '',
-        '- Review the complete branch diff against the plan and all accepted design constraints.',
-        '- Run the focused tests, affected package checks, generated-surface checks, and the repository readiness gate.',
-        '- For Noodle application behavior, also run the validation, test, check, preview, or hosted evidence level selected by the owning Noodle Seed build or verification skill.',
-        '- Report commits, evidence, residual risk, and the first unproven layer. Do not claim deployment, publication, merge, or production behavior that was not performed.',
-        '- Hand delivery to the repository workflow; executing a plan does not itself authorize merge, deploy, publication, or other external mutation.',
-        '',
-        '## Stop conditions',
-        '',
-        '- Stop before implementation when the plan is incomplete or stale in a way that changes behavior, architecture, security, or public contracts.',
-        '- Stop after three unsuccessful correction rounds on the same load-bearing finding.',
-        '- Stop before any external mutation or destructive action outside the user-authorized task boundary.',
-    ].join('\n');
-}
-//# sourceMappingURL=plan-execution-skill.js.map