diff --git a/CHANGELOG.md b/CHANGELOG.md
index 38fd3b8..17990c0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -67,6 +67,16 @@ platform API version.
 
 ### Changed
 
+- **One declaration of the webview's behaviour flags, the command ids and
+  the in-process chat tool.** `DiagramClientBehavior` (with
+  `AcpConnectorInfo`), `DiagramCommandIds` and `InProcessChatTool` live in
+  `@dialogram/shared`; the API re-exports them, the toolkit's
+  `SidecarClientBehavior`, `SidecarProfileCommandIds` and `RegistryChatTool`
+  are the shared types (the product-facing behaviour is
+  `ProductClientBehavior`, the shared type minus the four fields the platform
+  derives), and the webview reads them instead of its own copy. The test that
+  kept two hand-written twins in step is gone with the second twin.
+  `scriptInterpreterCommands` is deprecated: nothing reads it.
 - **One sidecar transport.** Six places each spawned the sidecar, wrote the
   request and parsed the answer with their own wording and deadlines: the
   invoker behind every diagram edit, the chat's `invokeSidecarOp` and
diff --git a/packages/diagram-client/src/profile.ts b/packages/diagram-client/src/profile.ts
index 7e242f4..7d26ea4 100644
--- a/packages/diagram-client/src/profile.ts
+++ b/packages/diagram-client/src/profile.ts
@@ -1,94 +1,16 @@
-import type { NodeFamilySpec } from '@dialogram/shared';
+import type { AcpConnectorInfo, DiagramClientBehavior, DiagramCommandIds, DiagramOperationKinds } from '@dialogram/shared';
 
-type DiagramCommandIds = {
-    fitToScreen?: string;
-    runWorkflow?: string;
-    stopWorkflow?: string;
-    setQueueTraceVisible?: string;
-    setAgentToolConfig?: string;
-    getAgentToolConfig?: string;
-};
-
-type DiagramOperationKinds = {
-    createEntityPort?: string;
-    deleteEntityPort?: string;
-};
-
-type DiagramClientBehavior = {
-    graphSourceNavigation?: boolean;
-    networkPropertySections?: boolean;
-    networkNavigationLabels?: boolean;
-    noneSentinel?: string;
-    scriptInterpreterCommands?: string[];
-    paletteIcons?: Record<string, { dark: string; light?: string }>;
-    nodeFamilies?: NodeFamilySpec[];
-    /** Whether the host has a chat backend; derived by the platform. */
-    chatBackend?: boolean;
-    /** The ACP connectors the runtime discovered or the user declared, for an
-     *  agent's `connector` (extension-core `AcpConnectorInfo`). */
-    acpConnectors?: AcpConnectorInfo[];
-    /** Whether a run can be resumed at a step of its queue trace. */
-    resumeAtStep?: boolean;
-    /** Where a nested workflow defined in another file opens: `in-place` shows it in
-     *  this editor, as a view of the editor's root (one editor per hierarchy);
-     *  `new-editor` (the default) opens the file in its own editor. */
-    nestedNavigation?: 'in-place' | 'new-editor';
-    /** Whether a double-click on a node that is not a network instance opens the
-     *  source it references in the text editor. Off (the default), such a node
-     *  does nothing on double-click. For a product whose leaves have a body of
-     *  their own that no diagram shows yet: an HDL module or entity of processes
-     *  and assignments lands at its definition. */
-    doubleClickOpensSource?: boolean;
-    /** Whether anything is written on a wire: the carried label (a width, a
-     *  payload type), the queue badge and last-token button of a run, the
-     *  index labels of a list connection. Default true. Off, an edge is its
-     *  line, and the tooltip on hover still says what it carries. 'once': as
-     *  true, but of the edges that leave or reach one port together with the
-     *  same carried label, only the first writes it; the others say it in
-     *  their tooltip (a node with many edges of one type, all on one trunk). */
-    edgeCaptions?: boolean | 'once';
-    /** Property-panel sections a product does without, each `false` to hide
-     *  it (all shown by default): `ports`, the input and output port lists, for
-     *  a product whose pins carry no meaning; `annotations`, the raw
-     *  definition annotations, for one whose facts already say it all;
-     *  `parameters`, the definition's parameters, for one whose nodes have
-     *  none (its own editable fields still show); `entityType`, Basic Info's
-     *  Type row (task, workflow) and its change-type button, for one whose
-     *  node kinds are its own. */
-    propertySections?: { ports?: boolean; annotations?: boolean; parameters?: boolean; entityType?: boolean };
-    /** The profile's status source, as the context menu offers it: "Show
-     *  <label>" runs `showCommand`, "Clear <label>" runs `clearCommand`.
-     *  Derived by the platform from the profile. */
-    statusSource?: { label: string; showCommand: string; clearCommand: string };
-    /** Whether selecting an element draws its path: what leads to it in one
-     *  colour, what it leads to in another, the rest faded. A node traces
-     *  every path through it, an edge itself and its two ends, a container
-     *  what feeds it and what it feeds across its frame; a path crosses group
-     *  frames as its edge does. Off by default. See selection-trace.ts. */
-    selectionTrace?: boolean;
-    /** What the hierarchy outline panel is called (its title, its button's
-     *  tooltip): plain words, "Hierarchy" by default. */
-    outlineTitle?: string;
-};
-
-export type AcpConnectorInfo = {
-    name: string;
-    available: boolean;
-    source: string;
-    command: string;
-    httpApi?: boolean;
-    model?: string | null;
-    mode?: string | null;
-};
+export type { AcpConnectorInfo, DiagramClientBehavior };
 
 type DiagramIdentifier = {
-    commandIds?: DiagramCommandIds;
-    operationKinds?: DiagramOperationKinds;
+    commandIds?: Partial<DiagramCommandIds>;
+    operationKinds?: Partial<DiagramOperationKinds>;
     settingsNamespace?: string;
     clientBehavior?: DiagramClientBehavior;
 };
 
-type DiagramCommandKey = keyof Required<DiagramCommandIds>;
+/** The commands the webview itself runs; the rest the host registers for its own menus. */
+type DiagramCommandKey = 'fitToScreen' | 'runWorkflow' | 'stopWorkflow' | 'setQueueTraceVisible' | 'setAgentToolConfig' | 'getAgentToolConfig';
 type DiagramOperationKey = keyof Required<DiagramOperationKinds>;
 
 const DEFAULT_COMMAND_IDS: Record<DiagramCommandKey, string> = {
diff --git a/packages/diagram-client/test/client-behavior-flags.test.ts b/packages/diagram-client/test/client-behavior-flags.test.ts
index 84bd90c..3d740d7 100644
--- a/packages/diagram-client/test/client-behavior-flags.test.ts
+++ b/packages/diagram-client/test/client-behavior-flags.test.ts
@@ -16,16 +16,14 @@ const WFPY_BEHAVIOR = {
     graphSourceNavigation: false,
     networkPropertySections: false,
     networkNavigationLabels: false,
-    noneSentinel: 'wfpy-none',
-    scriptInterpreterCommands: ['python', 'python3']
+    noneSentinel: 'wfpy-none'
 };
 
 const CALPY_BEHAVIOR = {
     graphSourceNavigation: true,
     networkPropertySections: true,
     networkNavigationLabels: true,
-    noneSentinel: 'wfpy-none',
-    scriptInterpreterCommands: ['python', 'python3']
+    noneSentinel: 'wfpy-none'
 };
 
 function inject(behavior: unknown): void {
@@ -48,10 +46,6 @@ describe('clientBehavior flag consumption', () => {
         expect(cb.networkNavigationLabels === true).toBe(false);
         // property-panel CLI-tools "none" sentinel
         expect(cb.noneSentinel).toBe('wfpy-none');
-        // views.ts icon detection
-        expect((cb.scriptInterpreterCommands ?? []).includes('python')).toBe(true);
-        expect((cb.scriptInterpreterCommands ?? []).includes('python3')).toBe(true);
-        expect((cb.scriptInterpreterCommands ?? []).includes('bash')).toBe(false);
     });
 
     it('resolves the calpy truth table (network behaviors on)', () => {
@@ -61,8 +55,6 @@ describe('clientBehavior flag consumption', () => {
         expect(cb.networkPropertySections === true).toBe(true);
         expect(cb.networkNavigationLabels === true).toBe(true);
         expect(cb.noneSentinel).toBe('wfpy-none');
-        expect((cb.scriptInterpreterCommands ?? []).includes('python')).toBe(true);
-        expect((cb.scriptInterpreterCommands ?? []).includes('python3')).toBe(true);
     });
 
     it('reads as all-off with no sentinel when nothing is injected (dev/standalone)', () => {
@@ -71,7 +63,6 @@ describe('clientBehavior flag consumption', () => {
         expect(cb.networkPropertySections === true).toBe(false);
         expect(cb.networkNavigationLabels === true).toBe(false);
         expect(cb.noneSentinel).toBeUndefined();
-        expect((cb.scriptInterpreterCommands ?? []).includes('python')).toBe(false);
     });
 
     it('ignores a non-object clientBehavior payload', () => {
diff --git a/packages/diagram-server/src/server/mcp-platform-tool-adapter.ts b/packages/diagram-server/src/server/mcp-platform-tool-adapter.ts
index f398280..402c228 100644
--- a/packages/diagram-server/src/server/mcp-platform-tool-adapter.ts
+++ b/packages/diagram-server/src/server/mcp-platform-tool-adapter.ts
@@ -27,26 +27,14 @@ import {
     type McpToolResult
 } from '@eclipse-glsp/server-mcp';
 import { jsonSchemaToZodShape } from './json-schema-to-zod';
+import type { InProcessChatTool } from '@dialogram/shared';
 
 /**
- * Structural shape of an in-process, read-only chat tool bridged into MCP. Mirrors the
- * platform's `InProcessChatTool` without importing it, keeping diagram-server free of an
- * extension-core dependency. `handler` receives the session's scoped file and the tool args.
+ * An in-process chat tool as the bridge sees it: the platform's `InProcessChatTool`, read-only.
+ * A tool whose `mutates` is true is never bridged here (the generated handler inherits
+ * `readOnlyHint = true`); {@link bridgeableChatTools} filters it out (see `mcp-diagram-module.ts`).
  */
-export interface PlatformMcpTool {
-    readonly name: string;
-    readonly description: string;
-    readonly inputSchema: Record<string, unknown>;
-    handler(file: string, args: Record<string, unknown>): string | Promise<string>;
-    /**
-     * When `true`, this tool WRITES source and MUST NOT be bridged here: the generated
-     * handler inherits `readOnlyHint = true`, so an auto-approving MCP client could invoke
-     * it and mutate files unconfirmed. Locked design (approach B): mutation-capable tools
-     * ride the GLSP-MCP built-in operation tools only. {@link bridgeableChatTools} filters
-     * these out (see `mcp-diagram-module.ts`).
-     */
-    readonly mutates?: boolean;
-}
+export type PlatformMcpTool = Readonly<InProcessChatTool>;
 
 /** Diagram-scope input = the base `{ sessionId }` plus whatever the tool's schema declares. */
 type PlatformToolInput = { sessionId: string } & Record<string, unknown>;
diff --git a/packages/extension-core/src/api.ts b/packages/extension-core/src/api.ts
index fe11689..f6c6440 100644
--- a/packages/extension-core/src/api.ts
+++ b/packages/extension-core/src/api.ts
@@ -14,6 +14,10 @@
  */
 import type * as vscode from "vscode";
 import type {
+  DiagramClientBehavior,
+  DiagramCommandIds,
+  DiagramOperationKinds,
+  InProcessChatTool,
   EditStrategy,
   DiagramNavigationProvider,
   DiagramModelSource,
@@ -26,7 +30,16 @@ import type {
   ExecutionOverlaySink,
 } from "@dialogram/shared";
 
-export type { DiagramClientAssets, EntityPaletteItemSpec, NodeFamilySpec } from "@dialogram/shared";
+export type {
+  AcpConnectorInfo,
+  DiagramClientAssets,
+  DiagramClientBehavior,
+  DiagramCommandIds,
+  DiagramOperationKinds,
+  EntityPaletteItemSpec,
+  InProcessChatTool,
+  NodeFamilySpec,
+} from "@dialogram/shared";
 
 import type {
   ChatCommandContribution,
@@ -49,45 +62,8 @@ export const DIALOGRAM_API_VERSION = "0.8.0";
 /** The extension id consumers pass to `vscode.extensions.getExtension`. */
 export const DIALOGRAM_EXTENSION_ID = "ebezati.dialogram";
 
-/**
- * The command ids a diagram profile owns. Members are consumer-owned strings so
- * two installed consumers never collide. Neutral successor of the pre-0.2.0
- * per-extension command-ids type.
- */
-export interface DiagramCommandIds {
-  openDiagram: string;
-  openDiagramSplit: string;
-  layoutDiagram: string;
-  refreshDiagramModel: string;
-  renameEntityByName: string;
-  undo: string;
-  redo: string;
-  fitToScreen: string;
-  center: string;
-  exportSvg: string;
-  toggleGrid: string;
-  setQueueTraceVisible: string;
-  stopWorkflow: string;
-  runWorkflow: string;
-  layoutDiagramIfNeeded: string;
-  setAgentToolConfig: string;
-  getAgentToolConfig: string;
-  /** @deprecated Nothing registers or runs it; accepted and ignored. */
-  createAgentToolPolicyFile?: string;
-  /** @deprecated Nothing registers or runs it; accepted and ignored. */
-  chatAddViewerEditor?: string;
-  /** @deprecated Nothing registers or runs it; accepted and ignored. */
-  chatAddViewerTask?: string;
-  createNewContainer: string;
-}
-
 /** Port operation-kind strings surfaced to the diagram client. Neutral
  *  successor of the pre-0.2.0 per-extension operation-kinds type. */
-export interface DiagramOperationKinds {
-  createEntityPort: string;
-  deleteEntityPort: string;
-}
-
 /**
  * Neutral storage runtime options core forwards to the diagram server: the
  * settings namespace, the operation-prefix surfaced to the client, and the
@@ -331,121 +307,6 @@ export interface DiagramStatusContext {
  * here. External-tool-backed consumers assemble one with the toolkit's profile
  * builder.
  */
-/**
- * Neutral, behavior-named client capability flags a consumer injects into the
- * diagram webview via `window.diagramIdentifier`. Each field names a client
- * behavior; the consumer supplies the per-product truth value. Core/client code
- * consults these flags instead of comparing a product-identity string.
- */
-/** One ACP connector as the platform read it (the known agents, the user's
- *  and the workspace's files): what an agent node may name. */
-export interface AcpConnectorInfo {
-  name: string;
-  /** The connector's command resolves on the PATH. */
-  available: boolean;
-  /** discovered | user | workspace */
-  source: string;
-  command: string;
-  /** The process also serves opencode's HTTP API (revert, message ids). */
-  httpApi?: boolean;
-  model?: string | null;
-  mode?: string | null;
-  env?: Record<string, string>;
-}
-
-export interface DiagramClientBehavior {
-  /** The ACP connectors the property panel offers on an agent's `connector`;
-   *  listed per document by the platform from {@link DiagramChatConfig.acpConnector}. */
-  acpConnectors?: AcpConnectorInfo[];
-  /** Cross-file drill-down navigation resolves through the graph source model. */
-  graphSourceNavigation?: boolean;
-  /** Property panel renders the network-model sections and labels. */
-  networkPropertySections?: boolean;
-  /** Cross-file navigation UI uses the network entity vocabulary. */
-  networkNavigationLabels?: boolean;
-  /** Sentinel option value/default for the agent CLI-tools "none" selection. */
-  noneSentinel?: string;
-  /** Node `cmd` values (lower-case) that render with the script-tool icon. */
-  scriptInterpreterCommands?: string[];
-  /**
-   * Artwork for icon ids this product uses, keyed by id.
-   *
-   * A palette icon is only a CSS class — GLSP renders `<i class="codicon
-   * codicon-<id>">` — so an icon exists only if some rule draws it. The
-   * platform's own rules cannot carry a product's mark, so a product supplies
-   * the image and the webview writes the rule.
-   *
-   * Each value is a complete `url(...)` source: a `data:image/svg+xml,...` URI
-   * is the portable choice, since a webview cannot load arbitrary file paths.
-   * `light`/`dark` are picked by the viewer's theme; give only `dark` and it is
-   * used for both.
-   */
-  paletteIcons?: Record<string, { dark: string; light?: string }>;
-  nodeFamilies?: NodeFamilySpec[];
-  /** Where a nested workflow defined in another file opens: `in-place` shows it in
-   *  this editor, as a view of the editor's root (one editor per hierarchy);
-   *  `new-editor` (the default) opens the file in its own editor. */
-  nestedNavigation?: 'in-place' | 'new-editor';
-  /** Whether a double-click on a node that is not a network instance opens the
-   *  source it references in the text editor. Off (the default), such a node
-   *  does nothing on double-click. For a product whose leaves have a body of
-   *  their own that no diagram shows yet: an HDL module or entity of processes
-   *  and assignments lands at its definition. */
-  doubleClickOpensSource?: boolean;
-  /** Whether anything is written on a wire: the carried label (a width, a
-   *  payload type), the queue badge and last-token button of a run, the
-   *  index labels of a list connection. Default true. Off, an edge is its
-   *  line, and the tooltip on hover still says what it carries. 'once': as
-   *  true, but of the edges that leave or reach one port together with the
-   *  same carried label, only the first writes it; the others say it in
-   *  their tooltip (a node with many edges of one type, all on one trunk). */
-  edgeCaptions?: boolean | 'once';
-  /** Whether selecting an element draws its path: what leads to it in one
-   *  colour, what it leads to in another, the rest faded. A node traces every
-   *  path through it, an edge itself and its two ends, a container what feeds
-   *  it and what it feeds across its frame; a path crosses group frames as
-   *  its edge does. Off by default. */
-  selectionTrace?: boolean;
-  /** Property-panel sections a product does without, each `false` to hide it:
-   *  `ports` (the input and output port lists), `annotations` (the raw
-   *  definition annotations), `parameters` (the definition's parameters; a
-   *  producer's editable fields still show), `entityType` (Basic Info's Type
-   *  row and its change-type button). All shown by default. */
-  propertySections?: { ports?: boolean; annotations?: boolean; parameters?: boolean; entityType?: boolean };
-  /** What the hierarchy outline panel is called (its title and its button's
-   *  tooltip); "Hierarchy" by default. */
-  outlineTitle?: string;
-  /**
-   * Whether the host has a chat backend behind this diagram.
-   *
-   * Derived by the platform from `DiagramProfile.chat`, not supplied by a
-   * product: the two must agree, and a field a product sets by hand is a field
-   * it can set wrongly. Read it, do not write it.
-   *
-   * The stock feature module boots a chat panel eagerly. When the host has no
-   * chat backend, that panel opened, sent its first message into a host with no
-   * handler for it, logged an unknown-method error, and timed out five seconds
-   * later — leaving a chat button that could never answer. A consumer that
-   * composes the stock features without configuring chat is a normal thing to
-   * be; the platform documents that module as the stock product's feature set,
-   * which is precisely the case that has to degrade quietly.
-   */
-  chatBackend?: boolean;
-  /**
-   * Whether a run can be resumed at a step of its queue trace, which turns on
-   * the stepper's resume button and "Rerun from here". Derived from the
-   * product's run arguments for it (`cliResumeArgs`), not set by hand.
-   */
-  resumeAtStep?: boolean;
-  /**
-   * The profile's status source, as the diagram's context menu offers it:
-   * its label and its two commands. Derived by the platform from
-   * `DiagramProfile.statusSource`, like {@link chatBackend}; read it, do not
-   * write it.
-   */
-  statusSource?: { label: string; showCommand: string; clearCommand: string };
-}
-
 export interface DiagramProfile {
   key: string;
   displayName: string;
@@ -637,31 +498,6 @@ export interface ChatPayload {
  */
 export type ChatMessageSink = (uri: string, payload: ChatPayload) => void;
 
-/**
- * An MCP tool served in-process over loopback HTTP. The handler receives the
- * absolute path of the file the session is scoped to and the tool arguments,
- * and returns the tool's text result — it can read live host-side state
- * (e.g. an in-memory graph store) directly.
- */
-export interface InProcessChatTool {
-  name: string;
-  description: string;
-  inputSchema: Record<string, unknown>;
-  handler(
-    file: string,
-    args: Record<string, unknown>,
-  ): string | Promise<string>;
-  /**
-   * When `true`, this tool WRITES source and MUST NOT be bridged onto the read-only
-   * GLSP-MCP surface, whose handlers inherit `readOnlyHint = true` (an auto-approving MCP
-   * client could otherwise mutate files unconfirmed). Locked design (approach B):
-   * mutation-capable tools ride the GLSP-MCP built-in operation tools only. The diagram
-   * server's bridge filters on this explicit marker; the tool stays available on the
-   * in-host chat / in-process MCP path.
-   */
-  mutates?: boolean;
-}
-
 export interface DialogramApi {
   apiVersion: string;
   /**
diff --git a/packages/shared/src/chat-tools.ts b/packages/shared/src/chat-tools.ts
new file mode 100644
index 0000000..21c981d
--- /dev/null
+++ b/packages/shared/src/chat-tools.ts
@@ -0,0 +1,21 @@
+/**
+ * An MCP tool served in-process over loopback HTTP. The handler receives the
+ * absolute path of the file the session is scoped to and the tool arguments,
+ * and returns the tool's text result — it can read live host-side state
+ * (e.g. an in-memory graph store) directly.
+ */
+export interface InProcessChatTool {
+    name: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    handler(file: string, args: Record<string, unknown>): string | Promise<string>;
+    /**
+     * When `true`, this tool WRITES source and MUST NOT be bridged onto the read-only
+     * GLSP-MCP surface, whose handlers inherit `readOnlyHint = true` (an auto-approving MCP
+     * client could otherwise mutate files unconfirmed). Locked design (approach B):
+     * mutation-capable tools ride the GLSP-MCP built-in operation tools only. The diagram
+     * server's bridge filters on this explicit marker; the tool stays available on the
+     * in-host chat / in-process MCP path.
+     */
+    mutates?: boolean;
+}
diff --git a/packages/shared/src/client-behavior.ts b/packages/shared/src/client-behavior.ts
new file mode 100644
index 0000000..cc67890
--- /dev/null
+++ b/packages/shared/src/client-behavior.ts
@@ -0,0 +1,125 @@
+/**
+ * What the webview is told about the product behind a diagram, through
+ * `window.diagramIdentifier.clientBehavior`. Each field names a behaviour;
+ * the product supplies its truth value, and the client reads these instead of
+ * comparing a product-identity string. One declaration for the host, the
+ * toolkit and the webview.
+ */
+import type { NodeFamilySpec } from './diagram-seams';
+
+/** One ACP connector as the platform read it (the known agents, the user's
+ *  and the workspace's files): what an agent node may name. */
+export interface AcpConnectorInfo {
+    name: string;
+    /** The connector's command resolves on the PATH. */
+    available: boolean;
+    /** discovered | user | workspace */
+    source: string;
+    command: string;
+    /** The process also serves opencode's HTTP API (revert, message ids). */
+    httpApi?: boolean;
+    model?: string | null;
+    mode?: string | null;
+    env?: Record<string, string>;
+}
+
+export interface DiagramClientBehavior {
+    /** The ACP connectors the property panel offers on an agent's `connector`;
+     *  listed per document by the platform from the profile's `chat.acpConnector`. */
+    acpConnectors?: AcpConnectorInfo[];
+    /** Cross-file drill-down navigation resolves through the graph source model. */
+    graphSourceNavigation?: boolean;
+    /** Property panel renders the network-model sections and labels. */
+    networkPropertySections?: boolean;
+    /** Cross-file navigation UI uses the network entity vocabulary. */
+    networkNavigationLabels?: boolean;
+    /** Sentinel option value/default for the agent CLI-tools "none" selection. */
+    noneSentinel?: string;
+    /** @deprecated Nothing reads it (node families decide the icon); accepted and ignored. */
+    scriptInterpreterCommands?: string[];
+    /**
+     * Artwork for icon ids this product uses, keyed by id.
+     *
+     * A palette icon is only a CSS class — GLSP renders `<i class="codicon
+     * codicon-<id>">` — so an icon exists only if some rule draws it. The
+     * platform's own rules cannot carry a product's mark, so a product supplies
+     * the image and the webview writes the rule.
+     *
+     * Each value is a complete `url(...)` source: a `data:image/svg+xml,...` URI
+     * is the portable choice, since a webview cannot load arbitrary file paths.
+     * `light`/`dark` are picked by the viewer's theme; give only `dark` and it is
+     * used for both.
+     */
+    paletteIcons?: Record<string, { dark: string; light?: string }>;
+    nodeFamilies?: NodeFamilySpec[];
+    /** Where a nested workflow defined in another file opens: `in-place` shows it in
+     *  this editor, as a view of the editor's root (one editor per hierarchy);
+     *  `new-editor` (the default) opens the file in its own editor. */
+    nestedNavigation?: 'in-place' | 'new-editor';
+    /** Whether a double-click on a node that is not a network instance opens the
+     *  source it references in the text editor. Off (the default), such a node
+     *  does nothing on double-click. For a product whose leaves have a body of
+     *  their own that no diagram shows yet: an HDL module or entity of processes
+     *  and assignments lands at its definition. */
+    doubleClickOpensSource?: boolean;
+    /** Whether anything is written on a wire: the carried label (a width, a
+     *  payload type), the queue badge and last-token button of a run, the
+     *  index labels of a list connection. Default true. Off, an edge is its
+     *  line, and the tooltip on hover still says what it carries. 'once': as
+     *  true, but of the edges that leave or reach one port together with the
+     *  same carried label, only the first writes it; the others say it in
+     *  their tooltip (a node with many edges of one type, all on one trunk). */
+    edgeCaptions?: boolean | 'once';
+    /** Whether selecting an element draws its path: what leads to it in one
+     *  colour, what it leads to in another, the rest faded. A node traces every
+     *  path through it, an edge itself and its two ends, a container what feeds
+     *  it and what it feeds across its frame; a path crosses group frames as
+     *  its edge does. Off by default. */
+    selectionTrace?: boolean;
+    /** Property-panel sections a product does without, each `false` to hide it:
+     *  `ports` (the input and output port lists), `annotations` (the raw
+     *  definition annotations), `parameters` (the definition's parameters; a
+     *  producer's editable fields still show), `entityType` (Basic Info's Type
+     *  row and its change-type button). All shown by default. */
+    propertySections?: { ports?: boolean; annotations?: boolean; parameters?: boolean; entityType?: boolean };
+    /** What the hierarchy outline panel is called (its title and its button's
+     *  tooltip); "Hierarchy" by default. */
+    outlineTitle?: string;
+    /**
+     * Whether the host has a chat backend behind this diagram.
+     *
+     * Derived by the platform from `DiagramProfile.chat`, not supplied by a
+     * product: the two must agree, and a field a product sets by hand is a field
+     * it can set wrongly. Read it, do not write it.
+     *
+     * The stock feature module boots a chat panel eagerly. When the host has no
+     * chat backend, that panel opened, sent its first message into a host with no
+     * handler for it, logged an unknown-method error, and timed out five seconds
+     * later — leaving a chat button that could never answer. A consumer that
+     * composes the stock features without configuring chat is a normal thing to
+     * be; the platform documents that module as the stock product's feature set,
+     * which is precisely the case that has to degrade quietly.
+     */
+    chatBackend?: boolean;
+    /**
+     * Whether a run can be resumed at a step of its queue trace, which turns on
+     * the stepper's resume button and "Rerun from here". Derived from the
+     * product's run arguments for it (`cliResumeArgs`), not set by hand.
+     */
+    resumeAtStep?: boolean;
+    /**
+     * The profile's status source, as the diagram's context menu offers it:
+     * its label and its two commands. Derived by the platform from
+     * `DiagramProfile.statusSource`, like {@link chatBackend}; read it, do not
+     * write it.
+     */
+    statusSource?: { label: string; showCommand: string; clearCommand: string };
+}
+
+/**
+ * The fields a product may set. The other four ({@link DiagramClientBehavior.chatBackend},
+ * `acpConnectors`, `resumeAtStep`, `statusSource`) the platform derives on
+ * the way to the webview; a product-facing type that declared them would
+ * invite setting them by hand, the one way the two halves could disagree.
+ */
+export type ProductClientBehavior = Omit<DiagramClientBehavior, 'chatBackend' | 'acpConnectors' | 'resumeAtStep' | 'statusSource'>;
diff --git a/packages/shared/src/command-ids.ts b/packages/shared/src/command-ids.ts
new file mode 100644
index 0000000..a1ecf6b
--- /dev/null
+++ b/packages/shared/src/command-ids.ts
@@ -0,0 +1,37 @@
+/**
+ * The command ids a diagram profile owns. Members are consumer-owned strings so
+ * two installed consumers never collide. Neutral successor of the pre-0.2.0
+ * per-extension command-ids type.
+ */
+/** The product's operation kinds for the two entity-port edits, as the webview dispatches them. */
+export interface DiagramOperationKinds {
+    createEntityPort: string;
+    deleteEntityPort: string;
+}
+
+export interface DiagramCommandIds {
+    openDiagram: string;
+    openDiagramSplit: string;
+    layoutDiagram: string;
+    refreshDiagramModel: string;
+    renameEntityByName: string;
+    undo: string;
+    redo: string;
+    fitToScreen: string;
+    center: string;
+    exportSvg: string;
+    toggleGrid: string;
+    setQueueTraceVisible: string;
+    stopWorkflow: string;
+    runWorkflow: string;
+    layoutDiagramIfNeeded: string;
+    setAgentToolConfig: string;
+    getAgentToolConfig: string;
+    /** @deprecated Nothing registers or runs it; accepted and ignored. */
+    createAgentToolPolicyFile?: string;
+    /** @deprecated Nothing registers or runs it; accepted and ignored. */
+    chatAddViewerEditor?: string;
+    /** @deprecated Nothing registers or runs it; accepted and ignored. */
+    chatAddViewerTask?: string;
+    createNewContainer: string;
+}
diff --git a/packages/shared/src/index.ts b/packages/shared/src/index.ts
index 7a53891..50544ac 100644
--- a/packages/shared/src/index.ts
+++ b/packages/shared/src/index.ts
@@ -15,5 +15,8 @@ export * from './diagram-seams';
 export * from './hierarchy';
 export * from './chat-seams';
 export * from './create-task-type-operation';
+export * from './client-behavior';
+export * from './command-ids';
+export * from './chat-tools';
 export * from './entity-names';
 export * from './clipboard-payload';
diff --git a/packages/sidecar-toolkit/src/registry-tools.ts b/packages/sidecar-toolkit/src/registry-tools.ts
index 5e93d06..66fb2bc 100644
--- a/packages/sidecar-toolkit/src/registry-tools.ts
+++ b/packages/sidecar-toolkit/src/registry-tools.ts
@@ -18,32 +18,11 @@
  */
 
 import { DEFAULT_EXPORT_OP, type SidecarOpResult } from './sidecar-graph-export.js';
+import type { InProcessChatTool } from '@dialogram/shared';
 import { summarizeValidation } from './validation-summary.js';
 
-/**
- * Structural twin of the platform's `InProcessChatTool` (kept local so the
- * toolkit needs no `@dialogram/extension-core` dependency). `handler` receives
- * the session's absolute file path and the tool args and returns text.
- */
-export interface RegistryChatTool {
-  name: string;
-  description: string;
-  inputSchema: Record<string, unknown>;
-  handler(file: string, args: Record<string, unknown>): Promise<string>;
-  /**
-   * When `true`, this tool WRITES source (via the sidecar) and MUST NOT be bridged onto
-   * the read-only GLSP-MCP surface — the platform adapter's handlers inherit
-   * `readOnlyHint = true`, so an auto-approving MCP client could otherwise mutate files
-   * unconfirmed. Locked design (approach B): mutation-capable tools ride the GLSP-MCP
-   * BUILT-IN operation tools only; the bridge filters on this explicit marker (not a name
-   * match — see `bridgeableChatTools`).
-   *
-   * No assembled registry tool sets this (type creation is a reversible GLSP operation tool).
-   * The marker + filter are KEPT as a DEFENSIVE guardrail so any future source-writing chat
-   * tool is still excluded from the read-only bridge.
-   */
-  mutates?: boolean;
-}
+/** A registry tool is an in-process chat tool, the platform's own shape: `handler` gets the session's file and the args and returns text. */
+export type RegistryChatTool = InProcessChatTool;
 
 /** Injected sidecar transport: invoke `<prefix>.<opName>` for `file` with `args`. */
 export type RegistrySidecarInvoke = (
diff --git a/packages/sidecar-toolkit/src/sidecar-diagram-profile.ts b/packages/sidecar-toolkit/src/sidecar-diagram-profile.ts
index 4141d47..beb0782 100644
--- a/packages/sidecar-toolkit/src/sidecar-diagram-profile.ts
+++ b/packages/sidecar-toolkit/src/sidecar-diagram-profile.ts
@@ -11,7 +11,7 @@
  * needs no `@dialogram/extension-core` dependency; the shell annotates the
  * result as `DiagramProfile` at the assignment site.
  */
-import type { DiagramClientAssets, EntityPaletteItemSpec, NodeFamilySpec } from '@dialogram/shared';
+import type { DiagramClientAssets, DiagramCommandIds, EntityPaletteItemSpec, NodeFamilySpec, ProductClientBehavior } from '@dialogram/shared';
 import * as vscode from 'vscode';
 import { DEFAULT_EXPORT_OP, invokeSidecarOp } from './sidecar-graph-export.js';
 import { createSourceReferenceContext } from './chat-source-reference.js';
@@ -54,44 +54,8 @@ import {
  */
 const AGENT_TOOL_OVERRIDES_STATE_KEY = 'workflow.agentToolEntityOverrides';
 
-/**
- * Neutral, behavior-named client capability flags the shell supplies and the
- * platform forwards into the diagram webview. Structural twin of the platform's
- * `DiagramClientBehavior`; kept local so the toolkit needs no extension-core dep.
- */
-export interface SidecarClientBehavior {
-    paletteIcons?: Record<string, { dark: string; light?: string }>;
-    nodeFamilies?: NodeFamilySpec[];
-    graphSourceNavigation?: boolean;
-    networkPropertySections?: boolean;
-    networkNavigationLabels?: boolean;
-    noneSentinel?: string;
-    scriptInterpreterCommands?: string[];
-    /** Where a nested workflow defined in another file opens: `in-place` shows it in
-     *  this editor, as a view of the editor's root (one editor per hierarchy);
-     *  `new-editor` (the default) opens the file in its own editor. */
-    nestedNavigation?: 'in-place' | 'new-editor';
-    /** Whether a double-click on a node that is not a network instance opens the
-     *  source it references in the text editor. Off (the default), such a node
-     *  does nothing on double-click. For a product whose leaves have a body of
-     *  their own that no diagram shows yet: an HDL module or entity of processes
-     *  and assignments lands at its definition. */
-    doubleClickOpensSource?: boolean;
-    /** Whether anything is written on a wire: the carried label (a width, a
-     *  payload type), the queue badge and last-token button of a run, the
-     *  index labels of a list connection. Default true. Off, an edge is its
-     *  line, and the tooltip on hover still says what it carries. 'once': as
-     *  true, but of the edges that leave or reach one port together with the
-     *  same carried label, only the first writes it; the others say it in
-     *  their tooltip (a node with many edges of one type, all on one trunk). */
-    edgeCaptions?: boolean | 'once';
-    /** Whether selecting an element draws its path (upstream and downstream, the rest faded), across group frames. Off by default. */
-    selectionTrace?: boolean;
-    /** Property-panel sections the product does without (`ports`, `annotations`, `parameters`, `entityType`), each `false` to hide it. */
-    propertySections?: { ports?: boolean; annotations?: boolean; parameters?: boolean; entityType?: boolean };
-    /** What the hierarchy outline panel is called; "Hierarchy" by default. */
-    outlineTitle?: string;
-}
+/** The webview behaviour flags a product sets; the platform's `DiagramClientBehavior` minus what it derives itself. */
+export type SidecarClientBehavior = ProductClientBehavior;
 
 /**
  * The command ids a sidecar diagram profile carries. A product may name any of
@@ -100,33 +64,9 @@ export interface SidecarClientBehavior {
  * `<sidecarOperationPrefix>.sidecar.edit` / `.send` for the two raw sidecar
  * commands. The derived id is what every product spelled by hand before.
  */
-export interface SidecarProfileCommandIds {
-    openDiagram: string;
-    openDiagramSplit: string;
-    layoutDiagram: string;
-    refreshDiagramModel: string;
-    renameEntityByName: string;
-    undo: string;
-    redo: string;
-    fitToScreen: string;
-    center: string;
-    exportSvg: string;
-    toggleGrid: string;
-    setQueueTraceVisible: string;
-    stopWorkflow: string;
-    runWorkflow: string;
-    layoutDiagramIfNeeded: string;
-    setAgentToolConfig: string;
-    getAgentToolConfig: string;
-    /** @deprecated Nothing registers or runs it; accepted and ignored. */
-    createAgentToolPolicyFile?: string;
-    /** @deprecated Nothing registers or runs it; accepted and ignored. */
-    chatAddViewerEditor?: string;
-    /** @deprecated Nothing registers or runs it; accepted and ignored. */
-    chatAddViewerTask?: string;
+export interface SidecarProfileCommandIds extends DiagramCommandIds {
     sidecarEdit: string;
     sidecarSend: string;
-    createNewContainer: string;
 }
 
 /**
diff --git a/packages/sidecar-toolkit/test/client-behavior-twin.test.ts b/packages/sidecar-toolkit/test/client-behavior-twin.test.ts
deleted file mode 100644
index 752367e..0000000
--- a/packages/sidecar-toolkit/test/client-behavior-twin.test.ts
+++ /dev/null
@@ -1,98 +0,0 @@
-/**
- * `SidecarClientBehavior` is a structural twin of the platform's
- * `DiagramClientBehavior` — deliberately duplicated so the toolkit needs no
- * extension-core dependency, and passed straight through
- * (`clientBehavior: input.clientBehavior`) with no mapping step that could
- * notice a gap.
- *
- * That makes the two declarations a silent-failure pair: a field added to the
- * platform side and forgotten here is dropped from every sidecar profile with
- * no error anywhere — the feature simply never arrives in the webview.
- *
- * This compares the two declarations as SOURCE. A `type Equal<…>` assertion
- * reads better and would catch nothing: vitest strips types without checking
- * them, and `npm run typecheck` only covers `src/**`, so nothing in this
- * directory is ever typechecked. Verified by drifting the twin and watching
- * both stay green.
- */
-import { readFileSync } from 'node:fs';
-import * as path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { describe, expect, it } from 'vitest';
-
-const here = path.dirname(fileURLToPath(import.meta.url));
-
-/** Field names of one interface declaration, in declaration order. */
-function fieldsOf(file: string, name: string): string[] {
-    const source = readFileSync(file, 'utf8');
-    const start = source.indexOf(`interface ${name} {`);
-    expect(start, `${name} not found in ${path.basename(file)}`).toBeGreaterThan(-1);
-    const body = source.slice(source.indexOf('{', start) + 1, source.indexOf('\n}', start));
-    return [...body.matchAll(/^\s*(\w+)\??\s*:/gm)].map(m => m[1]);
-}
-
-/**
- * Fields the PLATFORM computes and a product must never supply.
- *
- * The twin exists so a product-supplied field cannot go missing on the way to
- * the webview. A derived field is the opposite case: it reaches the webview by
- * being filled in during forwarding, and a product-facing type that declared it
- * would invite someone to set it by hand — which is the one way the two halves
- * could then disagree.
- *
- * So these are excluded from the comparison deliberately, and named here rather
- * than filtered by a pattern, because adding one is a decision worth writing
- * down.
- *
- *   chatBackend    derived from `DiagramProfile.chat` being present, which is
- *                  what decides whether the host activates a chat backend at all
- *   acpConnectors  listed per document by the platform from the profile's
- *                  `chat.acpConnector` declaration and posted to the webview;
- *                  a product declaring it by hand would name connectors the
- *                  machine may not have
- *   resumeAtStep   derived by the toolkit from the product's `cliResumeArgs`:
- *                  the button is there exactly when the run driver can build
- *                  the arguments it needs
- *   statusSource   derived from `DiagramProfile.statusSource`: the context
- *                  menu offers exactly the commands the host registered
- */
-const PLATFORM_DERIVED = ['chatBackend', 'acpConnectors', 'resumeAtStep', 'statusSource'];
-
-describe('sidecar client behavior mirrors the platform', () => {
-    const sidecar = fieldsOf(
-        path.join(here, '../src/sidecar-diagram-profile.ts'),
-        'SidecarClientBehavior'
-    );
-    const platform = fieldsOf(
-        path.join(here, '../../extension-core/src/api.ts'),
-        'DiagramClientBehavior'
-    ).filter(field => !PLATFORM_DERIVED.includes(field));
-
-    it('reads both declarations', () => {
-        // Guards the parser itself: an empty list would make every check below
-        // pass without comparing anything.
-        expect(sidecar.length).toBeGreaterThan(4);
-        expect(platform.length).toBeGreaterThan(4);
-    });
-
-    it('carries every field the platform declares', () => {
-        expect(sidecar).toEqual(expect.arrayContaining(platform));
-    });
-
-    it('declares no field the platform does not have', () => {
-        expect(platform).toEqual(expect.arrayContaining(sidecar));
-    });
-
-    it('leaves the platform-derived fields out of the product-facing type', () => {
-        // The exclusion above is only honest if the field is genuinely absent.
-        // Declaring it here would let a product set a value the platform then
-        // overwrites, which is worse than not offering it.
-        for (const derived of PLATFORM_DERIVED) {
-            expect(sidecar, `${derived} is computed by the platform`).not.toContain(derived);
-        }
-    });
-
-    it('forwards the palette icons a product contributes', () => {
-        expect(sidecar).toContain('paletteIcons');
-    });
-});