@mstar-harness/dsh 3.5.1 → 3.6.0-alpha.2

package/dist/gates/fallbacks-seeds.d.ts

@@ -14,7 +14,7 @@
  *    registry, so without preservation a mstar-only batch would strip
  *    preset/companion ids of their seeded annotations (rows remain — R2).
  * 2. `subagentRoleIds()` × `personaFor()` resolve the mstar personas from
- *    the `harness-agents/` mirror (the decoration's existing lookup surface;
+ *    the `harness-agents/` mirror (the persona channel's existing lookup surface;
  *    `mode: primary` shells like `project-manager` are excluded).
  * 3. Interpolation gate (HARD): any persona carrying the dsh system-prompt
  *    STRICT `{{...}}` hazard is skipped + warned BEFORE `declareSeeds` —
@@ -25,9 +25,10 @@
  *
  * The upstream `SeedDeclareOutcome` is passed through verbatim; the
  * structured `SeedOutcomeView` is this module's own view (the service is a
- * structural parameter — fake-testable, no runtime value import; the type
- * imports are type-only, mirroring `fallbacks-probe.ts` — the bundle keeps
- * ZERO runtime references to `dsh-llm-fallbacks`).
+ * structural parameter — fake-testable, no runtime value import). The
+ * upstream shapes are the local structural mirrors from
+ * `fallbacks-structural.ts` (mirroring `fallbacks-probe.ts`) — this module
+ * carries ZERO imports of `dsh-llm-fallbacks`, runtime or type.
  *
  * Failure semantics: a throwing readback is contained (skip + one warn —
  * probe semantics); a rejecting `declareSeeds` PROPAGATES to the caller —
@@ -37,7 +38,7 @@
  * Module boundary: no barrel — the entry imports this module by explicit
  * relative path; the entry does not re-export it.
  */
-import type { EffectiveRolesReadback, SeedDeclaration, SeedDeclareOutcome } from 'dsh-llm-fallbacks';
+import type { EffectiveRolesReadbackView, SeedDeclarationView, SeedDeclareOutcomeView } from './fallbacks-structural.ts';
 /** Logger label for the mstar seeds declaration (dsh logger naming: `<scope>/<subject>`). */
 export declare const SEEDS_LOGGER = "mstar/fallbacks-seeds";
 /** Seed-declaration log levels the module sink understands. */
@@ -46,15 +47,16 @@ export type SeedsLogLevel = 'debug' | 'warn' | 'error';
 export type SeedsLogSink = (level: SeedsLogLevel, message: string) => void;
 /**
  * The consumed service surface — a structural subset of the upstream
- * `FallbacksService` (the two seed methods the declaration flow uses).
+ * `FallbacksService` (the two seed methods the declaration flow uses),
+ * typed over the local mirrors in `fallbacks-structural.ts`.
  * Fake-testable: tests pass a spy object; the real service is assignable
  * (structural typing anchors the contract against the installed `.d.ts`).
  */
 export interface SeedsServiceView {
     /** (a) Declare the companion's FULL current seed set (replacement semantics). */
-    declareSeeds(seeds: readonly SeedDeclaration[]): Promise<SeedDeclareOutcome>;
+    declareSeeds(seeds: readonly SeedDeclarationView[]): Promise<SeedDeclareOutcomeView>;
     /** (b) Sync readback — effective taxonomy with seed annotations. */
-    getEffectiveRoles(): EffectiveRolesReadback;
+    getEffectiveRoles(): EffectiveRolesReadbackView;
 }
 /** Options for {@link declareMstarSeeds}. */
 export interface DeclareMstarSeedsOptions {
@@ -76,13 +78,13 @@ export interface PreservedSeedView {
 /** Structured result of one {@link declareMstarSeeds} call — this module's own view. */
 export interface SeedOutcomeView {
     /** The full declaration batch handed to `declareSeeds` (mstar personas + preserved ids). */
-    declared: SeedDeclaration[];
+    declared: SeedDeclarationView[];
     /** Locally skipped ids (interpolation gate / no usable default) — never declared. */
     skipped: SeedSkipView[];
     /** The seeded non-mstar ids preserved from the readback into the batch. */
     preserved: PreservedSeedView[];
     /** The upstream `SeedDeclareOutcome` — passed through verbatim. */
-    outcome: SeedDeclareOutcome;
+    outcome: SeedDeclareOutcomeView;
 }
 /**
  * Declare the mstar subagent seeds: readback → merge-preserve seeded

package/dist/gates/fallbacks-structural.d.ts

@@ -0,0 +1,101 @@
+/**
+ * Local structural mirrors of the consumed `dsh-llm-fallbacks` surface
+ * (plan `20260831-dsh-alpha2-optional-fallbacks` Task 2). dsh
+ * `0.1.2-alpha.2` natively covers subagent customization, so the fallbacks
+ * plugin is an OPTIONAL capability activated by the unchanged two-command
+ * install contract — and a dev-time-only dependency of this package (type
+ * mirroring here + the real-package test harness). The published package
+ * carries ZERO runtime AND ZERO type references to `dsh-llm-fallbacks`.
+ *
+ * Shapes mirror `dsh-llm-fallbacks@0.4.0-alpha.1` `dist/index.d.ts`
+ * (`FallbacksService`) and `dist/seeds.d.ts` (`SeedDeclaration`,
+ * `SeedSkipReason`, `SeedConflict`, `SeedDeclareOutcome`, `EffectiveRole`,
+ * `EffectiveRolesReadback`). Drift gates keeping the mirrors in sync:
+ *
+ * - Runtime: the probe spec's exact-keys `SERVICE_KEYS` 9-tuple +
+ *   `RESOLVED_VERSION` pin (`tests/fallbacks-probe.spec.ts`) fails on a
+ *   drifted resolver.
+ * - Compile-time: `typecheck:tests` compiles this module's consumers WITH
+ *   the real package's `declare module '@deepseek-ai/cordis'` augmentation
+ *   active (the tests import the package), so `fallbacksService`'s uncast
+ *   `ctx.get('llm-fallbacks')` return is a real → view assignability check.
+ *   The published build program never loads the augmentation — the untyped
+ *   string overload applies there.
+ *
+ * Only the members mstar consumes carry faithful signatures
+ * (`detectLegacyKeys`, `declareSeeds`, `getEffectiveRoles`); the remaining
+ * service members are presence-typed function slots — the probe spec's
+ * `typeof === 'function'` assertions are their executable gate.
+ *
+ * Module boundary: no barrel — consumers import this module by explicit
+ * relative path; the entry does not re-export it.
+ */
+/** Mirror of upstream `SeedSkipReason` (dist/seeds.d.ts) — per-id skip reason, never coercion. */
+export type SeedSkipReason = 'invalid-id' | 'reserved-id' | 'duplicate-in-batch';
+/** Mirror of upstream `SeedDeclaration` (dist/seeds.d.ts) — one companion seed. */
+export interface SeedDeclarationView {
+    id: string;
+    persona: string;
+}
+/** Mirror of upstream `SeedConflict` (dist/seeds.d.ts) — loud, non-destructive. */
+export interface SeedConflictView {
+    id: string;
+    /** Existing row persona differs from the seed default — operator override retained, never overwritten. */
+    kind: 'persona-source';
+}
+/** Mirror of upstream `SeedDeclareOutcome` (dist/seeds.d.ts) — one `declareSeeds` result. */
+export interface SeedDeclareOutcomeView {
+    applied: string[];
+    skipped: Array<{
+        id: string;
+        reason: SeedSkipReason;
+    }>;
+    conflicts: SeedConflictView[];
+}
+/** Mirror of upstream `EffectiveRole` (dist/seeds.d.ts) — readback entry with seed annotations. */
+export interface EffectiveRoleView {
+    /** The config row id (raw declared form). */
+    id: string;
+    /** Effective row persona. */
+    persona: string;
+    /** Passthrough — never touched by seeds. */
+    chain?: string[];
+    /** Passthrough — never touched by seeds (mirrors upstream `FallbackStrategy`). */
+    fallback?: 'inherit-root' | 'none';
+    /** Id is in the live declaration set (trimmed row-id match). */
+    seeded: boolean;
+    /** `seeded` && row persona !== current seed default. */
+    personaOverridden: boolean;
+    /** Present iff seeded. */
+    seedPersona?: string;
+}
+/** Mirror of upstream `EffectiveRolesReadback` (dist/seeds.d.ts) — effective taxonomy with seed annotations. */
+export interface EffectiveRolesReadbackView {
+    roles: EffectiveRoleView[];
+}
+/**
+ * Mirror of upstream `FallbacksService` (dist/index.d.ts) — the named
+ * cordis service `ctx.get('llm-fallbacks')` exposes while the plugin is
+ * applied. The 9 members are declared in the upstream order; the probe
+ * spec's `SERVICE_KEYS` tuple asserts exactly this set and order at runtime.
+ */
+export interface FallbacksServiceView {
+    /** Matches the plugin `name`. */
+    name: 'llm-fallbacks';
+    /** Package.json version string (module-load snapshot). */
+    version: string;
+    /** Presence-typed (unconsumed): role resolution. */
+    resolveRole: (...args: never[]) => unknown;
+    /** Presence-typed (unconsumed): chain resolution. */
+    resolveChain: (...args: never[]) => unknown;
+    /** Presence-typed (unconsumed): config validation. */
+    validateFallbacksConfig: (...args: never[]) => unknown;
+    /** Legacy config-key detector (consumed by the adoption advisory). */
+    detectLegacyKeys(source: Record<string, unknown>): string[];
+    /** (a) Declare the companion's FULL current seed set (replacement semantics). */
+    declareSeeds(seeds: readonly SeedDeclarationView[]): Promise<SeedDeclareOutcomeView>;
+    /** (b) Sync readback — effective taxonomy with seed annotations. */
+    getEffectiveRoles(): EffectiveRolesReadbackView;
+    /** Presence-typed (unconsumed): revert one id to the current seed default. */
+    revertSeededPersona: (...args: never[]) => unknown;
+}

package/dist/gates/goal-bridge.d.ts

@@ -128,7 +128,7 @@ export declare function rootAgentOf(agent: unknown, agents: AgentsView): unknown
  * Register the goal bridge: an `agent/session-start` listener (root filter
  * inside the mirror — root and children alike fire, `runtime-types.ts:217`)
  * plus a decision-point re-evaluation on `subagent/start` (the existing
- * decision point — index.ts decoration slot), resolving the delegating ROOT
+ * decision point — index.ts advisory slot), resolving the delegating ROOT
  * via the `parentSession` walk — the two mirror edges are idempotent (get +
  * compare when the mirror is in place — no churn) — plus a THIRD, advisory
  * listener on the `session/event` firehose (Task 3): a `goal/change`

package/dist/gates/role-persona.d.ts

@@ -0,0 +1,191 @@
+/**
+ * Native-first role-persona delivery (plan `20260831-dsh-alpha2-optional-fallbacks`
+ * Task 3): a role-matched subagent start merges the persona into the request's
+ * NATIVE `persona` slot (`@deepseek-ai/dsh-subagent`
+ * `SubagentStartRequest.persona`) — the additive `mstar:role-persona`
+ * system-prompt section is gone. Native semantics: the request persona
+ * registers the scoped `deployment:persona` section (order
+ * `DEPLOYMENT_PERSONA` = 0) on the child, SHADOWING the deployment persona
+ * for that child alone, is persisted in the child descriptor, and is
+ * reapplied on resume — delivery, persistence, and resume replay all belong
+ * to dsh. BOTH start surfaces are wrapped: the one-shot `start` AND the
+ * opt-in continuable `startContinuable` (tool-subagent
+ * `backgroundMode: 'continuable'` routes its background run through
+ * `ContinuableStartSpec.request`) — the old `subagent/start` emit
+ * decoration covered continuable children too, and this channel must not
+ * regress that.
+ *
+ * Interception seam: the cordis service-read waterfall
+ * (`Events['internal/get']`, `@deepseek-ai/cordis` 4.0.2
+ * `lib/types/events.d.ts`) — the framework's documented interception hook
+ * for values read through the context proxy. The listener wraps the
+ * `subagents` service VALUE on read (a prototype-delegating wrapper whose
+ * `start`/`startContinuable` merge the role persona into the request before
+ * delegating); the real `SubagentRuntime` object is never mutated — readers
+ * of `ctx.subagents` (the tool-subagent reads it per call through a
+ * plugin-fiber context) transparently receive the wrapper. The listener is
+ * owned by the applying fiber (cordis listener effects), so an HMR fiber
+ * swap unwinds and restores it like every other registration.
+ *
+ * The continuable request has no earlier seam: `registerContinuableSetup`
+ * contributions are child-scope installers (`(childCtx) => () => void` —
+ * no per-start data slot), so the earliest point where the continuable
+ * request exists is the `startContinuable(spec)` call itself, which the
+ * wrapper owns.
+ *
+ * Role identity uses the engine Assignment header grammar — the SAME
+ * parsers the dispatch gate uses (`assignmentHeaderRegion` +
+ * `parseAssignmentFields`) — over the start request's prompt text (the
+ * `ContentBlock[]` the child receives as its first user message). Persona
+ * lookup (plan `20260815-dsh-fallbacks-personas` Task 3) is the single
+ * {@link personaFor} surface — `Config.rolePersonas[executeAs]` →
+ * `harness-agents/` mirror default → skip (never gated on `roleMap` or on
+ * the fallbacks mounted state: persona delivery is fallbacks-independent).
+ * `roleMap` is a taxonomy bridge for logging + future rule-driven interop
+ * only. The mirror root is bound at apply (`setRolePersonaAgentsDir` ←
+ * `packagedAgentsDir()`), package-relative so the shipped bundle works from
+ * any launch cwd.
+ *
+ * Capability gates (native fail-loud contracts, per surface): one-shot
+ * `SubagentRuntime.start` REJECTS a request carrying `persona` for a
+ * provider whose `SubagentCapabilities.persona` is false (e.g.
+ * out-of-process providers) — "rejected rather than accepted-then-ignored"
+ * — so the one-shot merge checks `getProvider(name).capabilities.persona`
+ * first. Continuable children are composed by the continuation manager
+ * itself and are gated by `SubagentProvider.prepareContinuable` instead
+ * (upstream `SubagentCapabilities` doc: the flags "describe the ONE-SHOT
+ * path"), so the continuable merge checks `prepareContinuable` — the
+ * manager applies a merged persona unconditionally. Either way: gate miss →
+ * the persona is skipped with one contained debug log and the start
+ * proceeds unchanged — the contained degrade, never a failed dispatch.
+ *
+ * Precedence: an explicit `request.persona` (e.g. tool-subagent's own
+ * `Config.persona`) is caller intent and WINS — the role persona fills the
+ * slot only when the request does not already carry one.
+ *
+ * Degradation (the wrapper never throws before delegating — contained like
+ * the dispatch gate's degrade path): unparseable prompt / role-unmatched →
+ * silent pass-through; persona lookup miss with NO mirror → one debug log
+ * per apply (S-002 latch); a throwing merge aborts the merge only — the
+ * ORIGINAL request reaches the service and the start is never affected.
+ *
+ * Persona text is rendered by dsh system-prompt's STRICT `{{...}}`
+ * interpolation (the native persona has the same template semantics as the
+ * deployment persona), so persona values MUST NOT contain `{{` paired with
+ * a later `}}` — the Config schema rejects such values at plugin mount (see
+ * `_shared.ts` `rolePersonas` / `PERSONA_INTERPOLATION_HAZARD`); a mirror
+ * default carrying the hazard is warned + skipped at extraction (never a
+ * boot throw).
+ *
+ * Module boundary: no barrel — the entry imports this module by explicit
+ * relative path and re-exports the public names verbatim. No dsh-subagent
+ * dependency: the runtime surface is consumed structurally (same pattern as
+ * the probe's `LoaderEntryView` and T2's `fallbacks-structural.ts`).
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Config } from './_shared.ts';
+/** Logger label for the role-persona channel (dsh logger naming: `<scope>/<subject>`). */
+export declare const ROLE_PERSONA_LOGGER = "mstar/role-persona";
+/** One consumed prompt content block (`@deepseek-ai/dsh-llm` `ContentBlock` text members). */
+interface PromptBlockView {
+    readonly type: string;
+    readonly text?: string;
+}
+/**
+ * Structural view of the one-shot start request the channel merges into
+ * (`@deepseek-ai/dsh-subagent` `SubagentStartRequest` — consumed fields
+ * only: `prompt` is the role-extraction source, `persona` is the merge
+ * target). The wrapper forwards the request object SPREAD, so every
+ * non-consumed field (`label`, `parent`, `signal`, `agentOptions`, …)
+ * reaches the service unchanged at runtime; the view types only what this
+ * module reads. The continuable surface merges into the SAME view
+ * (`ContinuableStartSpec.request` is `Omit<SubagentStartRequest, 'label' |
+ * 'signal' | 'outputSchema'>` — same `prompt`/`persona` shape).
+ */
+export interface SubagentStartRequestView {
+    /** Content delivered as the child's user message (the Assignment carrier). */
+    readonly prompt: readonly PromptBlockView[];
+    /** Optional per-child persona — when already set, the caller wins. */
+    readonly persona?: string;
+}
+/**
+ * Structural view of the continuable start spec the channel merges into
+ * (`@deepseek-ai/dsh-subagent` `ContinuableStartSpec` — consumed fields
+ * only). The wrapper forwards the spec object SPREAD, so every
+ * non-consumed field (`label`, `childId`, `signal`) reaches the service
+ * unchanged at runtime; the view types only what this module reads.
+ */
+export interface ContinuableStartSpecView {
+    /** The `ctx.subagents` provider whose continuable creation establishes the child. */
+    readonly provider: string;
+    /** The delegation request (the merge target: same view as the one-shot request). */
+    readonly request: SubagentStartRequestView;
+}
+/**
+ * Structural view of the capability set the channel gates on
+ * (`@deepseek-ai/dsh-subagent` `SubagentCapabilities` — only `persona` is
+ * consumed: the ONE-SHOT fail-loud contract rejects a persona request for a
+ * provider without it, so the one-shot merge must pre-check).
+ */
+interface SubagentCapabilitiesView {
+    readonly persona?: boolean;
+}
+/**
+ * Structural view of one registered provider (`SubagentProvider` consumed
+ * surface). `prepareContinuable` is the NATIVE continuable gate (upstream:
+ * continuable children "are composed by the continuation manager itself
+ * and are gated by `SubagentProvider.prepareContinuable` instead") — its
+ * presence, not the one-shot `persona` flag, decides whether a merged
+ * persona can be honored on the continuable surface.
+ */
+interface SubagentProviderView {
+    readonly capabilities: SubagentCapabilitiesView;
+    readonly prepareContinuable?: unknown;
+}
+/**
+ * Structural view of the `subagents` runtime the wrapper delegates to
+ * (`@deepseek-ai/dsh-subagent` `SubagentRuntime` consumed surface:
+ * capability reads + one-shot and continuable starts). Start methods
+ * return the service's own promises/ids — opaque here, forwarded untouched.
+ */
+export interface SubagentsServiceView {
+    /** Look up a provider by name (the capability-gate read). */
+    getProvider(name: string): SubagentProviderView | undefined;
+    /** Establish one published child on the named provider (the delegated one-shot start). */
+    start(name: string, request: SubagentStartRequestView): unknown;
+    /** Establish one durable continuable child (the delegated continuable start). */
+    startContinuable(spec: ContinuableStartSpecView): unknown;
+}
+/** Role-persona log levels the module sink understands. */
+export type RolePersonaLogLevel = 'debug' | 'warn';
+/** Module-level log sink — bound by `apply` to `ctx.logger(ROLE_PERSONA_LOGGER)` (agent-flow ledger precedent). */
+export type RolePersonaLogSink = (level: RolePersonaLogLevel, message: string) => void;
+/**
+ * Bind the role-persona log sink (the entry `apply` binds it to
+ * `ctx.logger(ROLE_PERSONA_LOGGER)`). Returns the PRIOR sink so a caller
+ * can restore it (test pattern: agent-flow `setAgentFlowLogger`).
+ */
+export declare function setRolePersonaLogger(sink: RolePersonaLogSink): RolePersonaLogSink;
+/**
+ * Bind the persona-defaults mirror root. Returns the PRIOR binding so a
+ * caller can restore it (test pattern: {@link setRolePersonaLogger}).
+ * @param dir - the mirror root, or `undefined` to disable mirror defaults.
+ */
+export declare function setRolePersonaAgentsDir(dir: string | undefined): string | undefined;
+/**
+ * Register the native persona channel on the plugin's context: an
+ * `internal/get` waterfall listener (the cordis service-read interception
+ * hook) that wraps `ctx.subagents` reads. The listener is owned by the
+ * applying fiber — an HMR fiber swap unwinds it (reads return the raw
+ * service again) and a re-apply restores it.
+ *
+ * Never throws: the wrap step is contained — on any internal error the read
+ * returns the UNWRAPPED service value (persona delivery degrades, the
+ * runtime is untouched).
+ *
+ * @param ctx - the plugin's registrant context (the app composition root).
+ * @param config - validated plugin configuration (`rolePersonas` is the
+ *   only payload source; `roleMap` is never consulted for the merge).
+ */
+export declare function registerRolePersonaChannel(ctx: Context, config: Config): void;
+export {};

package/dist/gates/system-prompt.d.ts

@@ -3,9 +3,11 @@
  * Task 2): the root session's ONE `mstar:harness-rules` pointer section plus
  * the `mstar:engine-status` runtime-context summary, both registered on the
  * GLOBAL prompt layer — visible to the root session AND every dispatched
- * child — without touching the child-scoped `mstar:role-persona` section
- * (fallbacks-decoration; distinct name, distinct layer — duplicate-name
- * throws are per name per layer, verified `scope/src/store.ts`).
+ * child — on their own names and layers (the child persona rides the NATIVE
+ * subagent persona channel since plan
+ * `20260831-dsh-alpha2-optional-fallbacks` Task 3 — no child-scoped
+ * `mstar:role-persona` section exists anymore; duplicate-name throws remain
+ * per name per layer, verified `scope/src/store.ts`).
  *
  * Content discipline:
  * - The section is a POINTER block (presence / enforcement word / resolved
@@ -52,7 +54,7 @@
  *   re-read status.json / the compass / the ledger on every prompt
  *   assembly (the catalog's documented staleness tradeoff).
  *
- * Degradation (boot is never affected — the decoration's contained-degrade
+ * Degradation (boot is never affected — the persona channel's contained-degrade
  * discipline):
  * - Structural existence check via `ctx.get('systemPrompt')` — the
  *   `ctx.get('agents')` precedent: a DIRECT `ctx.systemPrompt` property
@@ -93,7 +95,7 @@ export declare const ENGINE_STATUS_CONTEXT_NAME = "mstar:engine-status";
 export declare const ENGINE_STATUS_CONTEXT_ORDER = 100;
 /** Harness-prompt log levels the module sink understands. */
 export type HarnessPromptLogLevel = 'debug' | 'warn';
-/** Module-level harness-prompt log sink — bound by `apply` to `ctx.logger(HARNESS_PROMPT_LOGGER)` (decoration precedent). */
+/** Module-level harness-prompt log sink — bound by `apply` to `ctx.logger(HARNESS_PROMPT_LOGGER)` (module-sink precedent). */
 export type HarnessPromptLogSink = (level: HarnessPromptLogLevel, message: string) => void;
 /**
  * Bind the harness-prompt log sink (the entry `apply` binds it to

package/dist/index.d.ts

@@ -26,8 +26,8 @@ export type { SkillLintAdvisory } from './gates/skill-lint.ts';
 export { SeamVetoError, lintSeamWrite, lintDesignMdWrite, lintAuditWrite, lintCompoundWrite, lintRolesWrite } from './gates/seams.ts';
 export type { SeamId, SeamLintAdvisory } from './gates/seams.ts';
 export type { DispatchGateAdvisory } from './gates/dispatch.ts';
-export { DECORATION_LOGGER, PERSONA_SECTION_NAME, PERSONA_SECTION_ORDER, decorateSubagentStart, setDecorationAgentsDir, setDecorationLogger, } from './gates/fallbacks-decoration.ts';
-export type { DecorationLogLevel, DecorationLogSink, SubagentRunInfoView } from './gates/fallbacks-decoration.ts';
+export { ROLE_PERSONA_LOGGER, registerRolePersonaChannel, setRolePersonaAgentsDir, setRolePersonaLogger, } from './gates/role-persona.ts';
+export type { RolePersonaLogLevel, RolePersonaLogSink, SubagentStartRequestView, SubagentsServiceView } from './gates/role-persona.ts';
 export { ADVISORY_LOGGER, runFallbacksAdvisory, setAdvisoryLogger } from './gates/fallbacks-advisory.ts';
 export type { AdvisoryLogLevel, AdvisoryLogSink } from './gates/fallbacks-advisory.ts';
 export { DshHostAdapter } from './gates/adapter.ts';