@lssm/lib.contracts-spec 17.3.2

package/dist/migrations.js

@@ -0,0 +1,69 @@
+export class MigrationRegistry{items=new Map;register(e){const t=a(e.meta.key,e.meta.version);if(this.items.has(t))throw Error(`Duplicate migration ${t}`);this.items.set(t,e);return this}list(){return[...this.items.values()].sort((e,t)=>{const i=e.meta.key.localeCompare(t.meta.key);return i!==0?i:r(e.meta.version,t.meta.version)})}get(e,t){if(t!=null)return this.items.get(a(e,t));let i;for(const n of this.items.values()){if(n.meta.key!==e)continue;if(!i||r(n.meta.version,i.meta.version)>0)i=n}return i}}import{compareVersions as r}from"compare-versions";const a=(e,t)=>`${e}.v${t}`;export const tech_contracts_migrations_DocBlocks=[{id:"docs.tech.contracts.migrations",title:"MigrationSpec Overview",summary:"`MigrationSpec` provides a declarative plan for schema/data/validation steps so migrations can be generated, reviewed, and executed safely by tooling. Each spec captures ownership metadata, target dialect, generated artifact provenance, ordered up/down steps, and optional dependency information. Runtime tooling can consume the spec to run SQL/data scripts with pre/post checks and produce audit logs.",kind:"reference",visibility:"public",route:"/docs/tech/contracts/migrations",tags:["tech","contracts","migrations"],body:`# MigrationSpec Overview
+
+## Purpose
+
+\`MigrationSpec\` provides a declarative plan for schema/data/validation steps so migrations can be generated, reviewed, and executed safely by tooling. Each spec captures ownership metadata, target dialect, generated artifact provenance, ordered up/down steps, and optional dependency information. Runtime tooling can consume the spec to run SQL/data scripts with pre/post checks and produce audit logs.
+
+## Location
+
+- Spec + registry: \`packages/libs/contracts/src/migrations.ts\`
+- Tests: \`packages/.../migrations.test.ts\`
+
+## Schema
+
+\`\`\`ts
+export interface MigrationSpec {
+  meta: MigrationMeta;   // ownership metadata + { name, version }
+  plan: {
+    up: MigrationStep[];   // required forward plan
+    down?: MigrationStep[];// optional rollback steps
+  };
+  dependencies?: string[]; // optional list of migration keys this depends on
+}
+\`\`\`
+
+- **MigrationStep**
+  - \`kind\`: \`'schema' | 'data' | 'validation'\`
+  - Shared fields: \`description?\`, \`timeoutMs?\`, \`retries?\`, \`preChecks?\`, \`postChecks?\`
+  - \`schema\`: \`sql\` string executed in transactional context
+  - \`data\`: arbitrary \`script\` (e.g., JS/TS snippet, path to file, instructions)
+  - \`validation\`: \`assertion\` expression verifying state (e.g., SQL returning boolean)
+- **MigrationCheck** (\`preChecks\`/\`postChecks\`)
+  - \`description\`: human context
+  - \`expression\`: expression or SQL snippet to evaluate before/after the step
+- **Dependencies**
+  - Array of migration keys (\`"boundedContext.namespace.timestamp_slug"\`) used to ensure the registry executes prerequisites first
+
+## Registry Usage
+
+\`\`\`ts
+import { MigrationRegistry } from '@lssm/lib.contracts-spec/migrations';
+import { AddUsersMigration } from './migrations/core.db.2025_01_add_users';
+
+const registry = new MigrationRegistry();
+registry.register(AddUsersMigration);
+
+const migration = registry.get('core.db.2025_01_add_users');
+const all = registry.list(); // sorted by name/version
+\`\`\`
+
+## Authoring Guidelines
+
+1. Name migrations with timestamped slugs (\`domain.db.YYYY_MM_description\`) for clarity.
+2. Capture ownership metadata (\`owners\`, \`tags\`, \`stability\`) so tooling can route approvals.
+3. Prefer small, reversible steps. Use \`plan.down\` when safe; otherwise document fallback.
+4. Use \`preChecks\`/\`postChecks\` for critical invariants (row counts, schema existence).
+5. Specify dependencies explicitly to avoid parallel execution hazards.
+6. For large data scripts, use \`script\` as a pointer (URL, file path) rather than embedding code directly.
+
+## Tooling Roadmap
+
+Upcoming CLI support (Phase 4 plan):
+
+- \`contractspec create --type migration\` (scaffolds spec skeleton)
+- \`contractspec build <migration>\` (generate executor harness)
+- \`contractspec migrate create/up/down/status\` orchestration commands
+
+The current implementation focuses on the spec/registry foundation so downstream tooling can be layered iteratively.
+
+`}];

package/dist/model-registry.d.ts

@@ -0,0 +1,9 @@
+import type { AnySchemaModel } from '@lssm/lib.schema/SchemaModel';
+/** In-memory registry for SchemaModel and SchemaType instances. */
+export declare class ModelRegistry {
+    private items;
+    constructor(items?: AnySchemaModel[]);
+    register(p: AnySchemaModel): this;
+    list(): AnySchemaModel[];
+    get(name: string): AnySchemaModel | undefined;
+}

package/dist/model-registry.js

@@ -0,0 +1 @@
+export class ModelRegistry{items=new Map;constructor(e){if(e)e.forEach((t)=>this.register(t))}register(e){const t=i(e);if(this.items.has(t))throw Error(`Duplicate contract \`model\` ${t}`);this.items.set(t,e);return this}list(){return[...this.items.values()]}get(e){return this.items.get(e)}}import{isSchemaModel as r}from"@lssm/lib.schema/SchemaModel";function i(e){if(r(e))return e.config.name;return"AnonymousSchema_"+Math.random().toString(36).substring(7)}

package/dist/navigation/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Navigation contract surface — public exports.
+ *
+ * See:
+ * - `nav-surface.ts` — `NavSurfaceItemSpec` (single nav entry).
+ * - `nav-graph.ts` — `NavGraphSpec` + `NavEdgeSpec` (relationship graph).
+ * - `registry.ts` — `NavRegistry` (persona/group/role-morph lookups).
+ */
+export { defineNavEdge, defineNavGraph, isNavEdgeSpec, isNavGraphSpec, type NavEdgeEndpointRef, type NavEdgeKind, type NavEdgeSpec, type NavGraphMeta, type NavGraphSpec, type NavGraphValidationIssue, type NavGraphValidationResult, validateNavGraph, } from './nav-graph.js';
+export { defineNavSurfaceItem, type IconKey, isNavSurfaceItemSpec, type NativeGestureHint, type NavDensityHint, type NavGroupKey, type NavRoutePath, type NavSurfaceItemSpec, type NavSurfaceMeta, type PersonaKey, } from './nav-surface.js';
+export { NavRegistry, type NavRegistryOptions, type ResolvedPreferenceProfileLike, type RoleMorphProjection, } from './registry.js';

package/dist/navigation/index.js

@@ -0,0 +1 @@
+export{defineNavEdge,defineNavGraph,isNavEdgeSpec,isNavGraphSpec,validateNavGraph}from"./nav-graph.js";export{defineNavSurfaceItem,isNavSurfaceItemSpec}from"./nav-surface.js";export{NavRegistry}from"./registry.js";

package/dist/navigation/nav-graph.d.ts

@@ -0,0 +1,79 @@
+/**
+ * NavGraphSpec — relationship graph over registered NavSurfaceItemSpec nodes.
+ *
+ * `nodes` are typically auto-derived from the `NavRegistry` (see registry.ts);
+ * `edges` are hand-maintained product knowledge (workflow→evidence→audit,
+ * inbox→threads, etc.). An optional `layout` reuses the existing
+ * `LayoutSpec` from `../data-views/layout-spec`.
+ */
+import type { LayoutSpec } from '../data-views/layout-spec.js';
+import type { OwnerShipMeta } from '../ownership.js';
+import { type NavSurfaceItemSpec } from './nav-surface.js';
+/** Semantic relationship between two nav surfaces. */
+export type NavEdgeKind = 'related' | 'leads-to' | 'escalates-to' | 'parent-of';
+/** Route-keyed reference to a nav item endpoint. */
+export interface NavEdgeEndpointRef {
+    readonly web: string;
+}
+/** Edge connecting two `NavSurfaceItemSpec` nodes by their `route.web`. */
+export interface NavEdgeSpec {
+    readonly from: NavEdgeEndpointRef;
+    readonly to: NavEdgeEndpointRef;
+    readonly kind: NavEdgeKind;
+    /** Optional positive weight (e.g. usage frequency / affinity). */
+    readonly weight?: number;
+}
+/** Metadata for a `NavGraphSpec`. Adds product context to `OwnerShipMeta`. */
+export interface NavGraphMeta extends OwnerShipMeta {
+    /** Why this graph exists (e.g. "power-user nav-map view"). */
+    goal: string;
+    /** Background, constraints, scope edges. */
+    context: string;
+}
+/**
+ * Navigation graph over registered nav surface items.
+ *
+ * `nodes` are typically derived from `NavRegistry.list()` so they stay in
+ * sync; `edges` describe hand-curated product relationships.
+ */
+export interface NavGraphSpec {
+    meta: NavGraphMeta;
+    nodes: readonly NavSurfaceItemSpec[];
+    edges: readonly NavEdgeSpec[];
+    /** Optional layout hint for the Nav Map renderer. */
+    layout?: LayoutSpec;
+}
+/** Identity helper for inline `NavGraphSpec` definitions. */
+export declare const defineNavGraph: (spec: NavGraphSpec) => NavGraphSpec;
+/** Identity helper for inline `NavEdgeSpec` definitions. */
+export declare const defineNavEdge: (edge: NavEdgeSpec) => NavEdgeSpec;
+/** Runtime type guard for `NavEdgeSpec`. */
+export declare function isNavEdgeSpec(value: unknown): value is NavEdgeSpec;
+/** Runtime type guard for `NavGraphSpec`. */
+export declare function isNavGraphSpec(value: unknown): value is NavGraphSpec;
+export interface NavGraphValidationIssue {
+    readonly level: 'error' | 'warning';
+    readonly message: string;
+    readonly path?: string;
+}
+export interface NavGraphValidationResult {
+    readonly valid: boolean;
+    readonly issues: readonly NavGraphValidationIssue[];
+}
+/**
+ * Validate edge integrity for a `NavGraphSpec`.
+ *
+ * Rules:
+ * - No self-loops (`from.web === to.web`).
+ * - Both endpoints must resolve to a node's `route.web`.
+ * - No duplicate `(from, to, kind)` triples.
+ */
+export declare function validateNavGraph(graph: NavGraphSpec): NavGraphValidationResult;
+export declare const navGraphDocBlock: {
+    id: string;
+    title: string;
+    body: string;
+    kind: "reference";
+    route: string;
+    visibility: "public";
+};

package/dist/navigation/nav-graph.js

@@ -0,0 +1,69 @@
+import{isNavSurfaceItemSpec as d}from"./nav-surface.js";const l=["related","leads-to","escalates-to","parent-of"];export const defineNavGraph=(a)=>a;export const defineNavEdge=(a)=>a;function s(a){if(!a||typeof a!=="object")return!1;const e=a;return typeof e.web==="string"&&e.web.length>0}export function isNavEdgeSpec(a){if(!a||typeof a!=="object")return!1;const e=a;if(!s(e.from))return!1;if(!s(e.to))return!1;if(typeof e.kind!=="string")return!1;if(!l.includes(e.kind))return!1;if(e.weight!==void 0&&(typeof e.weight!=="number"||!Number.isFinite(e.weight)||e.weight<0))return!1;return!0}export function isNavGraphSpec(a){if(!a||typeof a!=="object")return!1;const e=a;if(!e.meta||typeof e.meta!=="object")return!1;if(typeof e.meta.key!=="string"||e.meta.key.length===0)return!1;if(typeof e.meta.version!=="string"||e.meta.version.length===0)return!1;if(!Array.isArray(e.nodes))return!1;if(!e.nodes.every(d))return!1;if(!Array.isArray(e.edges))return!1;if(!e.edges.every(isNavEdgeSpec))return!1;return!0}export function validateNavGraph(a){const e=[],o=new Set(a.nodes.map((r)=>r.route.web)),i=new Set;a.edges.forEach((r,p)=>{const t=`edges[${p}]`;if(r.from.web===r.to.web)e.push({level:"error",message:`Self-loop edge on ${r.from.web}`,path:t});if(!o.has(r.from.web))e.push({level:"error",message:`Edge.from references unknown node: ${r.from.web}`,path:`${t}.from`});if(!o.has(r.to.web))e.push({level:"error",message:`Edge.to references unknown node: ${r.to.web}`,path:`${t}.to`});const n=`${r.kind}:${r.from.web}->${r.to.web}`;if(i.has(n))e.push({level:"warning",message:`Duplicate edge ${n}`,path:t});i.add(n)});return{valid:!e.some((r)=>r.level==="error"),issues:e}}export const navGraphDocBlock={id:"nav-graph-spec",title:"NavGraphSpec",body:`Relationship graph over registered navigation surface items with hand-curated product knowledge edges.
+
+## Overview
+
+\`NavGraphSpec\` models the navigation surface as a directed graph where:
+- **Nodes** are \`NavSurfaceItemSpec\` entries (typically auto-derived from \`NavRegistry.list()\`)
+- **Edges** are hand-maintained product relationships describing how surfaces relate
+- **Optional Layout** hints how to render the graph in the Nav Map viewer
+
+## Edge Semantics
+
+Edges use semantic kinds to express relationship intent:
+
+| Kind | Meaning | Example |
+|------|---------|---------|
+| \`related\` | Surfaces are related but not ordered | inbox \u2194 threads |
+| \`leads-to\` | Natural workflow progression | workflow \u2192 evidence |
+| \`escalates-to\` | Escalation path | support \u2192 escalation-queue |
+| \`parent-of\` | Hierarchical containment | analytics \u2192 analytics/usage |
+
+Each edge carries an optional \`weight\` (0..\u221E) indicating usage frequency or affinity.
+
+## Validation
+
+\`validateNavGraph\` ensures:
+- No self-loops
+- Both endpoints resolve to node routes
+- No duplicate (from, to, kind) triples
+
+## Integration with Design-System Graph Templates
+
+\`NavGraphSpec\` integrates with existing DS graph renderers:
+- \`ConversationGraphView\` \u2014 render conversation/discussion threads
+- \`WorkflowDagView\` \u2014 render workflow DAG
+- \`AgentTreeView\` \u2014 render agent hierarchy
+- \`EngineeringLoopView\` \u2014 render loop/feedback structures
+
+The Nav Map view at \`/companyos/nav-map\` renders the full \`NavGraphSpec\` to show power users the complete navigation topology.
+
+## Example
+
+\`\`\`typescript
+const navGraph = defineNavGraph({
+  meta: {
+    key: 'companyos-nav',
+    version: '1.0.0',
+    description: 'CompanyOS navigation graph',
+    goal: 'Enable power-user nav-map view and routing suggestions',
+    context: 'Global navigation topology for all personas',
+    owners: ['team-platform'],
+    tags: ['core', 'navigation'],
+  },
+  nodes: navRegistry.list(),
+  edges: [
+    defineNavEdge({
+      from: { web: '/companyos/workflow' },
+      to: { web: '/companyos/evidence' },
+      kind: 'leads-to',
+      weight: 2.5,
+    }),
+    defineNavEdge({
+      from: { web: '/companyos/inbox' },
+      to: { web: '/companyos/threads' },
+      kind: 'related',
+    }),
+  ],
+  layout: { type: 'force-directed', spacing: 200 },
+});
+\`\`\``,kind:"reference",route:"packages/libs/contracts-spec/src/navigation/nav-graph.ts",visibility:"public"};

package/dist/navigation/nav-surface.d.ts

@@ -0,0 +1,138 @@
+/**
+ * NavSurfaceItemSpec — single navigation entry contract.
+ *
+ * Mirrors the `PresentationSpec.capability` pattern from
+ * `src/presentations/presentations.ts` but for navigation items.
+ *
+ * A nav item is a hard binding to a registered capability: every entry
+ * MUST reference a `CapabilityRef` so that the host can validate at build
+ * time that every navigation surface is backed by a real capability.
+ */
+import type { CapabilityRef } from '../capabilities/capabilities.js';
+import type { DocId } from '../docs/index.js';
+import type { OwnerShipMeta } from '../ownership.js';
+import type { SurfacePolicyRequirement } from '../policy/requirements.js';
+/**
+ * Curated persona identifiers used by `personaVisibility`.
+ *
+ * Apps may extend with custom strings; the union accepts `string & {}` to
+ * preserve autocomplete on the curated values while staying open.
+ */
+export type PersonaKey = 'founder_approver' | 'operations_manager' | 'frontline_staff' | 'auditor' | 'enterprise_admin' | (string & {});
+/** Sidebar / nav group key (e.g. `'workflow'`, `'governance'`). */
+export type NavGroupKey = string;
+/** Logical icon key resolved by the host app to a concrete icon component. */
+export type IconKey = string;
+/** Optional density hint applied to a single nav entry. */
+export type NavDensityHint = 'compact' | 'comfortable';
+/**
+ * Declared gesture affordance for a native mobile navigation surface.
+ *
+ * Read by the Expo Router shell to configure gesture handlers without
+ * per-screen wiring in `_layout.tsx`.
+ *
+ * - `'swipe-back'`  — standard iOS back gesture (Expo Router default for stack screens)
+ * - `'swipe-left'`  — horizontal left swipe → next item (e.g. cockpit → work-graph)
+ * - `'swipe-right'` — horizontal right swipe → previous / dismiss
+ * - `'swipe-down'`  — dismiss sheet / read-only confirmation dismiss
+ * - `'none'`        — gestures explicitly disabled (e.g. auditor audit-log)
+ */
+export type NativeGestureHint = 'swipe-back' | 'swipe-left' | 'swipe-right' | 'swipe-down' | 'none';
+/**
+ * Route descriptor for a nav item.
+ *
+ * `web` is the canonical browser path (e.g. `/companyos/inbox`).
+ * `api` is the optional companion API root for routes that drive a workspace
+ * (e.g. `/api/companyos/inbox`).
+ */
+export interface NavRoutePath {
+    readonly web: string;
+    readonly api?: string;
+}
+/**
+ * Metadata for a `NavSurfaceItemSpec`, mirroring `PresentationSpecMeta`.
+ *
+ * Inherits `key`, `version`, `description`, `owners`, `tags`, `stability`
+ * from `OwnerShipMeta`, and adds product/UX context fields.
+ */
+export interface NavSurfaceMeta extends OwnerShipMeta {
+    /** Why this nav entry exists from a product/UX standpoint. */
+    goal: string;
+    /** Background, constraints, scope edges (feeds docs & LLM context). */
+    context: string;
+}
+/**
+ * Single navigation surface entry.
+ *
+ * Every field except `densityHint`, `policy`, and `docId` is required so the
+ * `NavRegistry` can build deterministic, role-aware navigation graphs.
+ */
+export interface NavSurfaceItemSpec {
+    meta: NavSurfaceMeta;
+    /**
+     * Hard binding to the capability that provides this navigation surface.
+     * REQUIRED — the host validates that every nav item resolves to a
+     * capability registered with `CapabilityRegistry.indexBySurface('navigation')`.
+     */
+    capability: CapabilityRef;
+    /** Canonical web + optional API route paths. */
+    route: NavRoutePath;
+    /** Personas allowed to see this nav entry. Empty array means hidden. */
+    personaVisibility: readonly PersonaKey[];
+    /** Sidebar/nav group this entry belongs to. */
+    groupKey: NavGroupKey;
+    /** Logical icon key resolved at render time. */
+    iconKey: IconKey;
+    /** Optional UI density preference for the rendered entry. */
+    densityHint?: NavDensityHint;
+    /** Optional policy guard applied on top of `personaVisibility`. */
+    policy?: SurfacePolicyRequirement;
+    /** Optional DocBlock references for cross-linking. */
+    docId?: DocId[];
+    /**
+     * Logical icon key for native tab bar rendering (platform-specific asset
+     * resolution). Separate from `iconKey` to allow distinct web-sidebar vs
+     * native-tab-bar icon sets.
+     *
+     * When absent the host may fall back to `iconKey` or a platform default.
+     * Only meaningful on tab-root items (`parentGroupKey` absent).
+     *
+     * @example `'tab.cockpit'`, `'tab.inbox'`, `'tab.audit-log'`
+     */
+    tabBarIcon?: string;
+    /**
+     * Declared gesture affordance for native screen navigation.
+     * Read by the Expo Router shell; no per-screen gesture wiring needed.
+     *
+     * Use `'none'` to explicitly disable back/dismiss gestures (e.g. auditor
+     * audit-log where accidental swipe-dismiss would lose evidence context).
+     */
+    gestureHint?: NativeGestureHint;
+    /**
+     * Key of the parent tab root's `groupKey`.
+     *
+     * - **Absent** (or `undefined`) → this item IS a tab-bar root.
+     * - **Present** → this item is a stack-child pushed onto the named tab's
+     *   navigator and does NOT appear in the tab bar.
+     *
+     * @example `'inbox'` — threads/[id] and handoffs are children of the inbox tab
+     */
+    parentGroupKey?: NavGroupKey;
+}
+/** Identity helper used by call sites to assert the spec shape. */
+export declare const defineNavSurfaceItem: (spec: NavSurfaceItemSpec) => NavSurfaceItemSpec;
+/**
+ * Runtime type guard for `NavSurfaceItemSpec`.
+ *
+ * Performs a shallow structural check — does not validate that referenced
+ * capabilities or policies exist (that is the registry's responsibility).
+ */
+export declare function isNavSurfaceItemSpec(value: unknown): value is NavSurfaceItemSpec;
+export declare const navSurfaceDocBlock: {
+    id: string;
+    title: string;
+    body: string;
+    kind: "reference";
+    route: string;
+    visibility: "public";
+};

package/dist/navigation/nav-surface.js

@@ -0,0 +1,70 @@
+export const defineNavSurfaceItem=(t)=>t;export function isNavSurfaceItemSpec(t){if(!t||typeof t!=="object")return!1;const e=t;if(!e.meta||typeof e.meta!=="object")return!1;if(typeof e.meta.key!=="string"||e.meta.key.length===0)return!1;if(typeof e.meta.version!=="string"||e.meta.version.length===0)return!1;if(!e.capability||typeof e.capability!=="object")return!1;if(typeof e.capability.key!=="string"||e.capability.key.length===0)return!1;if(!e.route||typeof e.route!=="object")return!1;if(typeof e.route.web!=="string"||e.route.web.length===0)return!1;if(e.route.api!==void 0&&typeof e.route.api!=="string")return!1;if(!Array.isArray(e.personaVisibility))return!1;if(e.personaVisibility.some((i)=>typeof i!=="string"))return!1;if(typeof e.groupKey!=="string"||e.groupKey.length===0)return!1;if(typeof e.iconKey!=="string"||e.iconKey.length===0)return!1;if(e.densityHint!==void 0&&e.densityHint!=="compact"&&e.densityHint!=="comfortable")return!1;if(e.tabBarIcon!==void 0&&typeof e.tabBarIcon!=="string")return!1;if(e.gestureHint!==void 0&&e.gestureHint!=="swipe-back"&&e.gestureHint!=="swipe-left"&&e.gestureHint!=="swipe-right"&&e.gestureHint!=="swipe-down"&&e.gestureHint!=="none")return!1;if(e.parentGroupKey!==void 0&&typeof e.parentGroupKey!=="string")return!1;return!0}export const navSurfaceDocBlock={id:"nav-surface-item-spec",title:"NavSurfaceItemSpec",body:`Single navigation entry contract that binds a capability to a web route with persona and grouping semantics. Includes optional mobile-extension fields for Expo Router native navigation (Phase D.0).
+
+## Overview
+
+\`NavSurfaceItemSpec\` mirrors the \`PresentationSpec.capability\` pattern and defines a hard binding between:
+- A registered **capability** that provides the navigation surface (validated against CapabilityRegistry)
+- A **route** (web path + optional API root)
+- **Persona visibility** (which personas can see this entry)
+- **Grouping** (sidebar/nav section)
+- **Icon** (logical key resolved at render time)
+
+## Key Semantics
+
+**Capability Binding**: Every nav item MUST reference a \`CapabilityRef\` so the host can validate at build time that every navigation surface is backed by a real capability registered with \`surface: 'navigation'\`.
+
+**Persona Visibility**: The \`personaVisibility\` array lists personas allowed to see the entry. An empty array means hidden from all personas.
+
+**Optional Policy**: The \`policy\` field adds an additional gate on top of persona visibility (e.g., require a feature flag or explicit permission).
+
+**Optional Density Hint**: The \`densityHint\` field suggests UI density ('compact' | 'comfortable') applied to the rendered entry.
+
+## Mobile Extension Fields (additive, Phase D.0)
+
+Three optional fields enable native Expo Router navigation without app-level hard-coding:
+
+**\`tabBarIcon?\`**: Logical icon key for native tab bar rendering, separate from the web sidebar \`iconKey\`. When absent the host may fall back to \`iconKey\` or a platform default. Only meaningful on tab-root items (\`parentGroupKey\` absent).
+
+**\`gestureHint?\`** (\`NativeGestureHint\`): Declares the primary gesture affordance for this screen. Use \`'none'\` to explicitly disable back/dismiss gestures (e.g. auditor audit-log where accidental swipe-dismiss would lose evidence context).
+
+**\`parentGroupKey?\`**: Expresses the tab-vs-stack hierarchy. Absent = item IS a tab-bar root. Present = item is a stack-child pushed onto the named tab's navigator and does NOT appear in the tab bar.
+
+Tab/stack hierarchy example:
+- \`cockpit\` \u2192 \`parentGroupKey: undefined\` \u2192 tab bar root
+- \`work-graph\` \u2192 \`parentGroupKey: 'cockpit'\` \u2192 stack child under cockpit tab
+- \`inbox\` \u2192 \`parentGroupKey: undefined\` \u2192 tab bar root
+- \`threads/[id]\` \u2192 \`parentGroupKey: 'inbox'\` \u2192 stack child under inbox tab
+
+Web shells ignore these fields (absent optional fields produce no effect).
+
+## Usage in NavRegistry
+
+The \`NavRegistry\` consumes \`NavSurfaceItemSpec\` entries and provides:
+- \`indexByPersona(persona)\`: Get all entries visible to a persona
+- \`indexByGroup(groupKey)\`: Get all entries in a nav group
+- \`resolveForRoleMorph(roleMorph, preferences)\`: Resolve visible entries for a role-morph projection (filtered by persona + hidden groups)
+
+## Example
+
+\`\`\`typescript
+const inboxNav = defineNavSurfaceItem({
+  meta: {
+    key: 'inbox',
+    version: '1.0.0',
+    description: 'Inbox navigation entry',
+    goal: 'Direct users to their messages and notifications',
+    context: 'Core workflow entry point for all personas',
+    owners: ['team-platform'],
+    tags: ['core', 'workflow'],
+  },
+  capability: { key: 'inbox.read' },
+  route: { web: '/companyos/inbox', api: '/api/companyos/inbox' },
+  personaVisibility: ['founder_approver', 'operations_manager', 'frontline_staff'],
+  groupKey: 'workflow',
+  iconKey: 'icon.inbox',
+  densityHint: 'comfortable',
+  // Mobile extension fields (optional \u2014 web shell ignores these)
+  tabBarIcon: 'tab.inbox',
+  gestureHint: 'swipe-back',
+});
+\`\`\``,kind:"reference",route:"packages/libs/contracts-spec/src/navigation/nav-surface.ts",visibility:"public"};

package/dist/navigation/registry.d.ts

@@ -0,0 +1,69 @@
+/**
+ * NavRegistry — registry for `NavSurfaceItemSpec` entries.
+ *
+ * Mirrors the `CapabilityRegistry` API surface (register / list / get /
+ * indexed queries) with persona- and group-aware lookups and an optional
+ * `CapabilityRegistry` binding check.
+ */
+import type { CapabilityRegistry } from '../capabilities/capabilities.js';
+import type { NavGroupKey, NavSurfaceItemSpec, PersonaKey } from './nav-surface.js';
+/**
+ * Minimal structural shape for the role-morph projection consumed by
+ * `resolveForRoleMorph`. Apps may pass a richer projection; only `personas`
+ * is read here.
+ */
+export interface RoleMorphProjection {
+    readonly personas: readonly PersonaKey[];
+}
+/**
+ * Minimal structural shape for the resolved preference profile consumed by
+ * `resolveForRoleMorph`. Apps may pass a richer profile.
+ */
+export interface ResolvedPreferenceProfileLike {
+    readonly density?: 'compact' | 'comfortable';
+    readonly hiddenGroups?: readonly NavGroupKey[];
+}
+/** Options accepted by the `NavRegistry` constructor. */
+export interface NavRegistryOptions {
+    /**
+     * Optional capability registry used to validate that every registered
+     * `NavSurfaceItemSpec.capability` resolves to a capability that declares
+     * `provides: [{ surface: 'navigation', key: <capability.key> }]`.
+     */
+    readonly capabilities?: CapabilityRegistry;
+}
+export declare class NavRegistry {
+    private readonly items;
+    private personaIndexCache;
+    private groupIndexCache;
+    private readonly capabilities?;
+    constructor(options?: NavRegistryOptions);
+    /** Register a nav item; throws on duplicate id or unresolved capability. */
+    register(spec: NavSurfaceItemSpec): this;
+    /** List all registered nav items in insertion order. */
+    list(): NavSurfaceItemSpec[];
+    /** Get a nav item by `meta.key` (returns latest version when omitted). */
+    get(key: string, version?: string): NavSurfaceItemSpec | undefined;
+    /** Get every nav item visible to a given persona. */
+    indexByPersona(persona: PersonaKey): NavSurfaceItemSpec[];
+    /** Get every nav item assigned to a given group key. */
+    indexByGroup(groupKey: NavGroupKey): NavSurfaceItemSpec[];
+    /**
+     * Resolve the nav surface visible to a role-morph projection.
+     *
+     * - Filters by `personaVisibility` intersected with `roleMorph.personas`.
+     * - Optionally hides groups listed in `preferences.hiddenGroups`.
+     * - De-duplicates by `meta.key` (latest registered wins).
+     */
+    resolveForRoleMorph(roleMorph: RoleMorphProjection, preferences?: ResolvedPreferenceProfileLike): NavSurfaceItemSpec[];
+    private buildPersonaIndex;
+    private buildGroupIndex;
+}
+export declare const navRegistryDocBlock: {
+    id: string;
+    title: string;
+    body: string;
+    kind: "how";
+    route: string;
+    visibility: "public";
+};

package/dist/navigation/registry.js

@@ -0,0 +1 @@
+export class NavRegistry{items=new Map;personaIndexCache=null;groupIndexCache=null;capabilities;constructor(e={}){this.capabilities=e.capabilities}register(e){const i=p(e);if(this.items.has(i))throw Error(`Duplicate nav item ${i}`);if(this.capabilities){const r=this.capabilities.indexBySurface("navigation"),t=`navigation:${e.capability.key}`;if(!r.has(t))throw Error(`Nav item ${i} references capability ${e.capability.key} which is not registered with surface 'navigation'`)}this.items.set(i,e);this.personaIndexCache=null;this.groupIndexCache=null;return this}list(){return[...this.items.values()]}get(e,i){if(i!==void 0)return this.items.get(`${e}.v${i}`);let r;for(const t of this.items.values()){if(t.meta.key!==e)continue;if(!r||t.meta.version>r.meta.version)r=t}return r}indexByPersona(e){return this.buildPersonaIndex().get(e)??[]}indexByGroup(e){return this.buildGroupIndex().get(e)??[]}resolveForRoleMorph(e,i){const r=new Set(e.personas),t=new Set(i?.hiddenGroups??[]),s=new Set,n=[];for(const a of this.items.values()){if(s.has(a.meta.key))continue;if(t.has(a.groupKey))continue;if(!a.personaVisibility.some((o)=>r.has(o)))continue;s.add(a.meta.key);n.push(a)}return n}buildPersonaIndex(){if(this.personaIndexCache)return this.personaIndexCache;const e=new Map;for(const i of this.items.values())for(const r of i.personaVisibility){const t=e.get(r)??[];t.push(i);e.set(r,t)}this.personaIndexCache=e;return e}buildGroupIndex(){if(this.groupIndexCache)return this.groupIndexCache;const e=new Map;for(const i of this.items.values()){const r=e.get(i.groupKey)??[];r.push(i);e.set(i.groupKey,r)}this.groupIndexCache=e;return e}}const p=(e)=>`${e.meta.key}.v${e.meta.version}`;export const navRegistryDocBlock={id:"nav-registry",title:"NavRegistry",body:"In-memory registry for navigation surface items with persona- and group-aware queries and capability binding validation.\n\n## Overview\n\n`NavRegistry` mirrors the `CapabilityRegistry` API and provides:\n- **Registration**: `register(spec)` with duplicate + capability validation\n- **Queries**: `get(key, version?)`, `list()`, `indexByPersona()`, `indexByGroup()`\n- **Role-aware resolution**: `resolveForRoleMorph(roleMorph, preferences)`\n\n## Registration Flow\n\n1. Create `NavSurfaceItemSpec` entries using `defineNavSurfaceItem()`\n2. Optionally pass a `CapabilityRegistry` to the `NavRegistry` constructor\n3. Call `register(spec)` for each entry\n   - Throws if `meta.key + version` is duplicate\n   - Throws if capability is not registered with `surface: 'navigation'` (when `CapabilityRegistry` is provided)\n4. Use queries to retrieve filtered nav items\n\n## resolveForRoleMorph Semantics\n\n`resolveForRoleMorph(roleMorph, preferences)` filters the registry to:\n1. **Persona intersection**: Keep entries where `personaVisibility` overlaps with `roleMorph.personas`\n2. **Group hiding**: Remove entries in `preferences.hiddenGroups`\n3. **De-duplication**: By `meta.key` (latest version wins)\n\nReturns a flat array of visible `NavSurfaceItemSpec` in insertion order.\n\n## CapabilityRegistry Binding Validation\n\nIf a `CapabilityRegistry` is provided at construction, `register()` validates that:\n- `spec.capability.key` is registered in capabilities with `surface: 'navigation'`\n- If not, throws: `\"Nav item {id} references capability {key} which is not registered with surface 'navigation'\"`\n\nThis ensures all nav items map to real capabilities at build time.\n\n## Index Caching\n\nBoth persona and group indexes are lazy-built and cached; they invalidate on `register()`.\n\n## Example Usage\n\n```typescript\nconst registry = new NavRegistry({ capabilities: capabilityRegistry });\n\nregistry.register(inboxNavSpec);\nregistry.register(workflowNavSpec);\nregistry.register(analyticsNavSpec);\n\n// Get entries visible to a persona\nconst founderNav = registry.indexByPersona('founder_approver');\n\n// Resolve for a role-morph with hidden groups\nconst visibleNav = registry.resolveForRoleMorph(\n  { personas: ['founder_approver', 'operations_manager'] },\n  { hiddenGroups: ['experimental'] }\n);\n\n// Build a NavGraphSpec from the registry\nconst graph = defineNavGraph({\n  meta: { /* ... */ },\n  nodes: registry.list(),\n  edges: [ /* hand-curated */ ],\n});\n```",kind:"how",route:"packages/libs/contracts-spec/src/navigation/registry.ts",visibility:"public"};

package/dist/node/acp/acp.feature.js

@@ -0,0 +1 @@
+import{defineFeature as e}from"../features/index.js";import{ACP_DOMAIN as o,ACP_OWNERS as s,ACP_STABILITY as t,ACP_TAGS as i}from"./constants.js";export const AcpFeature=e({meta:{key:"platform.acp",version:"1.0.0",title:"Agent Communication Protocol",description:"Session management and transport operations for agent communication (prompt turns, tool calls, terminal exec, fs access)",domain:o,owners:s,tags:[...i],stability:t},operations:[{key:"acp.session.init",version:"1.0.0"},{key:"acp.session.resume",version:"1.0.0"},{key:"acp.session.stop",version:"1.0.0"},{key:"acp.prompt.turn",version:"1.0.0"},{key:"acp.tool.calls",version:"1.0.0"},{key:"acp.terminal.exec",version:"1.0.0"},{key:"acp.fs.access",version:"1.0.0"}],capabilities:{provides:[{key:"acp.transport",version:"1.0.0"}]}});

package/dist/node/acp/capabilities/acpTransport.capability.js

@@ -0,0 +1,4 @@
+import{defineCapability as e}from"../../capabilities/index.js";import{docRef as o}from"../../docs/registry.js";import{ACP_DOMAIN as t,ACP_OWNERS as s,ACP_STABILITY as r,ACP_TAGS as i}from"../constants.js";export const AcpTransportDocBlock={id:"docs.tech.acp.transport",title:"ACP transport",summary:"Agent Client Protocol transport surfaces.",kind:"reference",visibility:"public",route:"/docs/tech/acp/transport",tags:["acp","transport"],body:`# ACP transport
+
+Defines the ContractSpec ACP server + client surfaces for HTTP streamable transport.
+`},AcpTransportCapability=e({meta:{key:"acp.transport",version:"1.0.0",kind:"integration",title:"ACP Transport",description:"Agent Client Protocol transport surfaces.",domain:t,owners:s,tags:[...i,"transport"],stability:r,docId:[o(AcpTransportDocBlock.id)]},provides:[{surface:"operation",key:"acp.session.init",version:"1.0.0",description:"Initialize ACP session."},{surface:"operation",key:"acp.session.resume",version:"1.0.0",description:"Resume ACP session."},{surface:"operation",key:"acp.session.stop",version:"1.0.0",description:"Stop ACP session."},{surface:"operation",key:"acp.prompt.turn",version:"1.0.0",description:"Execute prompt turn."},{surface:"operation",key:"acp.tool.calls",version:"1.0.0",description:"Execute ACP tool calls."},{surface:"operation",key:"acp.terminal.exec",version:"1.0.0",description:"Execute terminal command."},{surface:"operation",key:"acp.fs.access",version:"1.0.0",description:"Access filesystem via ACP."}]});

package/dist/node/acp/capabilities/index.js

@@ -0,0 +1 @@
+export*from"./acpTransport.capability.js";

package/dist/node/acp/commands/acpFsAccess.command.js

@@ -0,0 +1,4 @@
+import{ScalarTypeEnum as s,SchemaModel as e}from"@lssm/lib.schema";import{docRef as t}from"../../docs/registry.js";import{defineCommand as c}from"../../operations/index.js";import{ACP_DOMAIN as i,ACP_OWNERS as o,ACP_STABILITY as p,ACP_TAGS as a}from"../constants.js";const n=new e({name:"AcpFsAccessInput",fields:{sessionId:{type:s.ID(),isOptional:!1},operation:{type:s.String_unsecure(),isOptional:!1},path:{type:s.String_unsecure(),isOptional:!1},content:{type:s.String_unsecure(),isOptional:!0},options:{type:s.JSONObject(),isOptional:!0}}}),r=new e({name:"AcpFsAccessOutput",fields:{result:{type:s.JSONObject(),isOptional:!0}}});export const AcpFsAccessDocBlock={id:"docs.tech.acp.fs.access",title:"ACP file system access",summary:"Access file system through ACP.",kind:"reference",visibility:"public",route:"/docs/tech/acp/fs/access",tags:["acp","filesystem"],body:`# acp.fs.access
+
+Performs file system access with policy gating.
+`},AcpFsAccessCommand=c({meta:{key:"acp.fs.access",title:"ACP File System Access",version:"1.0.0",description:"Perform file system access within an ACP session.",goal:"Expose file system access through governed ACP transport.",context:"Used by ACP clients for read/write/list operations.",domain:i,owners:o,tags:[...a,"filesystem"],stability:p,docId:[t(AcpFsAccessDocBlock.id)]},capability:{key:"acp.transport",version:"1.0.0"},io:{input:n,output:r},policy:{auth:"admin",pii:[]}});

package/dist/node/acp/commands/acpPromptTurn.command.js

@@ -0,0 +1,4 @@
+import{ScalarTypeEnum as t,SchemaModel as o}from"@lssm/lib.schema";import{docRef as p}from"../../docs/registry.js";import{defineCommand as e}from"../../operations/index.js";import{ACP_DOMAIN as r,ACP_OWNERS as s,ACP_STABILITY as n,ACP_TAGS as i}from"../constants.js";const u=new o({name:"AcpPromptTurnInput",fields:{sessionId:{type:t.ID(),isOptional:!1},messages:{type:t.JSONObject(),isOptional:!1,isArray:!0},options:{type:t.JSONObject(),isOptional:!0}}}),a=new o({name:"AcpPromptTurnOutput",fields:{turnId:{type:t.ID(),isOptional:!1},status:{type:t.String_unsecure(),isOptional:!1},output:{type:t.JSONObject(),isOptional:!0}}});export const AcpPromptTurnDocBlock={id:"docs.tech.acp.prompt.turn",title:"ACP prompt turn",summary:"Execute a prompt turn within a session.",kind:"reference",visibility:"public",route:"/docs/tech/acp/prompt/turn",tags:["acp","prompt"],body:`# acp.prompt.turn
+
+Runs a prompt turn and returns structured outputs and tool calls.
+`},AcpPromptTurnCommand=e({meta:{key:"acp.prompt.turn",title:"ACP Prompt Turn",version:"1.0.0",description:"Execute a prompt turn within an ACP session.",goal:"Run ACP prompt turns with tool calls and structured outputs.",context:"Used by ACP clients to send messages and receive outputs.",domain:r,owners:s,tags:[...i,"prompt"],stability:n,docId:[p(AcpPromptTurnDocBlock.id)]},capability:{key:"acp.transport",version:"1.0.0"},io:{input:u,output:a},policy:{auth:"user",pii:[]}});

package/dist/node/acp/commands/acpSessionInit.command.js

@@ -0,0 +1,4 @@
+import{ScalarTypeEnum as s,SchemaModel as i}from"@lssm/lib.schema";import{docRef as e}from"../../docs/registry.js";import{defineCommand as t}from"../../operations/index.js";import{ACP_DOMAIN as n,ACP_OWNERS as o,ACP_STABILITY as a,ACP_TAGS as p}from"../constants.js";const c=new i({name:"AcpSessionInitInput",fields:{clientId:{type:s.String_unsecure(),isOptional:!0},sessionConfig:{type:s.JSONObject(),isOptional:!0},authContext:{type:s.JSONObject(),isOptional:!0},mode:{type:s.String_unsecure(),isOptional:!0}}}),r=new i({name:"AcpSessionInitOutput",fields:{sessionId:{type:s.ID(),isOptional:!1},status:{type:s.String_unsecure(),isOptional:!1},expiresAt:{type:s.DateTime(),isOptional:!0}}});export const AcpSessionInitDocBlock={id:"docs.tech.acp.session.init",title:"ACP session init",summary:"Initialize a new ACP session.",kind:"reference",visibility:"public",route:"/docs/tech/acp/session/init",tags:["acp","session"],body:`# acp.session.init
+
+Creates a new ACP session and returns session metadata.
+`},AcpSessionInitCommand=t({meta:{key:"acp.session.init",title:"ACP Session Init",version:"1.0.0",description:"Initialize a new ACP session.",goal:"Start a governed ACP session with configured tools and policies.",context:"Used by ACP clients to start a new session using HTTP streamable transport.",domain:n,owners:o,tags:[...p,"session"],stability:a,docId:[e(AcpSessionInitDocBlock.id)]},capability:{key:"acp.transport",version:"1.0.0"},io:{input:c,output:r},policy:{auth:"user",pii:[]}});

package/dist/node/acp/commands/acpSessionResume.command.js

@@ -0,0 +1,4 @@
+import{ScalarTypeEnum as s,SchemaModel as e}from"@lssm/lib.schema";import{docRef as i}from"../../docs/registry.js";import{defineCommand as o}from"../../operations/index.js";import{ACP_DOMAIN as t,ACP_OWNERS as n,ACP_STABILITY as p,ACP_TAGS as a}from"../constants.js";const c=new e({name:"AcpSessionResumeInput",fields:{sessionId:{type:s.ID(),isOptional:!1}}}),m=new e({name:"AcpSessionResumeOutput",fields:{sessionId:{type:s.ID(),isOptional:!1},status:{type:s.String_unsecure(),isOptional:!1}}});export const AcpSessionResumeDocBlock={id:"docs.tech.acp.session.resume",title:"ACP session resume",summary:"Resume an existing ACP session.",kind:"reference",visibility:"public",route:"/docs/tech/acp/session/resume",tags:["acp","session"],body:`# acp.session.resume
+
+Resumes a previously initialized ACP session.
+`},AcpSessionResumeCommand=o({meta:{key:"acp.session.resume",title:"ACP Session Resume",version:"1.0.0",description:"Resume an existing ACP session.",goal:"Continue a previously initialized ACP session with full context.",context:"Used by ACP clients to resume HTTP streamable sessions.",domain:t,owners:n,tags:[...a,"session"],stability:p,docId:[i(AcpSessionResumeDocBlock.id)]},capability:{key:"acp.transport",version:"1.0.0"},io:{input:c,output:m},policy:{auth:"user",pii:[]}});

package/dist/node/acp/commands/acpSessionStop.command.js

@@ -0,0 +1,4 @@
+import{ScalarTypeEnum as s,SchemaModel as t}from"@lssm/lib.schema";import{docRef as o}from"../../docs/registry.js";import{defineCommand as e}from"../../operations/index.js";import{ACP_DOMAIN as i,ACP_OWNERS as p,ACP_STABILITY as n,ACP_TAGS as a}from"../constants.js";const c=new t({name:"AcpSessionStopInput",fields:{sessionId:{type:s.ID(),isOptional:!1},reason:{type:s.String_unsecure(),isOptional:!0}}}),r=new t({name:"AcpSessionStopOutput",fields:{sessionId:{type:s.ID(),isOptional:!1},status:{type:s.String_unsecure(),isOptional:!1},stoppedAt:{type:s.DateTime(),isOptional:!0}}});export const AcpSessionStopDocBlock={id:"docs.tech.acp.session.stop",title:"ACP session stop",summary:"Stop an ACP session.",kind:"reference",visibility:"public",route:"/docs/tech/acp/session/stop",tags:["acp","session"],body:`# acp.session.stop
+
+Stops an active ACP session with audit trails.
+`},AcpSessionStopCommand=e({meta:{key:"acp.session.stop",title:"ACP Session Stop",version:"1.0.0",description:"Stop an active ACP session.",goal:"Terminate ACP sessions cleanly with audit trails.",context:"Used by ACP clients to stop sessions explicitly.",domain:i,owners:p,tags:[...a,"session"],stability:n,docId:[o(AcpSessionStopDocBlock.id)]},capability:{key:"acp.transport",version:"1.0.0"},io:{input:c,output:r},policy:{auth:"user",pii:[]}});

package/dist/node/acp/commands/acpTerminalExec.command.js

@@ -0,0 +1,4 @@
+import{ScalarTypeEnum as e,SchemaModel as t}from"@lssm/lib.schema";import{docRef as i}from"../../docs/registry.js";import{defineCommand as n}from"../../operations/index.js";import{ACP_DOMAIN as c,ACP_OWNERS as a,ACP_STABILITY as o,ACP_TAGS as r}from"../constants.js";const s=new t({name:"AcpTerminalExecInput",fields:{sessionId:{type:e.ID(),isOptional:!1},command:{type:e.String_unsecure(),isOptional:!1},cwd:{type:e.String_unsecure(),isOptional:!0},env:{type:e.JSONObject(),isOptional:!0}}}),m=new t({name:"AcpTerminalExecOutput",fields:{exitCode:{type:e.Int_unsecure(),isOptional:!0},stdout:{type:e.String_unsecure(),isOptional:!0},stderr:{type:e.String_unsecure(),isOptional:!0}}});export const AcpTerminalExecDocBlock={id:"docs.tech.acp.terminal.exec",title:"ACP terminal exec",summary:"Execute terminal commands via ACP.",kind:"reference",visibility:"public",route:"/docs/tech/acp/terminal/exec",tags:["acp","terminal"],body:`# acp.terminal.exec
+
+Executes terminal commands in a governed ACP session.
+`},AcpTerminalExecCommand=n({meta:{key:"acp.terminal.exec",title:"ACP Terminal Exec",version:"1.0.0",description:"Execute a terminal command within an ACP session.",goal:"Expose terminal execution with governance and auditing.",context:"Used by ACP clients when terminal access is granted.",domain:c,owners:a,tags:[...r,"terminal"],stability:o,docId:[i(AcpTerminalExecDocBlock.id)]},capability:{key:"acp.transport",version:"1.0.0"},io:{input:s,output:m},policy:{auth:"admin",pii:[]}});

package/dist/node/acp/commands/acpToolCalls.command.js

@@ -0,0 +1,4 @@
+import{ScalarTypeEnum as o,SchemaModel as t}from"@lssm/lib.schema";import{docRef as l}from"../../docs/registry.js";import{defineCommand as e}from"../../operations/index.js";import{ACP_DOMAIN as s,ACP_OWNERS as a,ACP_STABILITY as c,ACP_TAGS as i}from"../constants.js";const n=new t({name:"AcpToolCallsInput",fields:{sessionId:{type:o.ID(),isOptional:!1},toolCalls:{type:o.JSONObject(),isOptional:!1,isArray:!0}}}),p=new t({name:"AcpToolCallsOutput",fields:{results:{type:o.JSONObject(),isOptional:!1,isArray:!0}}});export const AcpToolCallsDocBlock={id:"docs.tech.acp.tool.calls",title:"ACP tool calls",summary:"Execute ACP tool calls.",kind:"reference",visibility:"public",route:"/docs/tech/acp/tool/calls",tags:["acp","tools"],body:`# acp.tool.calls
+
+Executes tool calls with governance and telemetry.
+`},AcpToolCallsCommand=e({meta:{key:"acp.tool.calls",title:"ACP Tool Calls",version:"1.0.0",description:"Execute tool calls within an ACP session.",goal:"Run tool calls with safe governance and telemetry.",context:"Used by ACP clients when the agent requests tool execution.",domain:s,owners:a,tags:[...i,"tools"],stability:c,docId:[l(AcpToolCallsDocBlock.id)]},capability:{key:"acp.transport",version:"1.0.0"},io:{input:n,output:p},policy:{auth:"user",pii:[]}});

package/dist/node/acp/commands/index.js

@@ -0,0 +1 @@
+export*from"./acpFsAccess.command.js";export*from"./acpPromptTurn.command.js";export*from"./acpSessionInit.command.js";export*from"./acpSessionResume.command.js";export*from"./acpSessionStop.command.js";export*from"./acpTerminalExec.command.js";export*from"./acpToolCalls.command.js";

package/dist/node/acp/constants.js

@@ -0,0 +1 @@
+import{StabilityEnum as t,TagsEnum as o}from"../ownership.js";export const ACP_DOMAIN="acp",ACP_OWNERS=["platform.ai"],ACP_TAGS=[o.Automation,"acp","transport"],ACP_STABILITY=t.Experimental;

package/dist/node/acp/contracts.js

@@ -0,0 +1 @@
+import{AcpTransportCapability as e}from"./capabilities/index.js";import{AcpFsAccessCommand as t,AcpPromptTurnCommand as i,AcpSessionInitCommand as o,AcpSessionResumeCommand as p,AcpSessionStopCommand as s,AcpTerminalExecCommand as a,AcpToolCallsCommand as n}from"./commands/index.js";export const acpOperationContracts={AcpSessionInitCommand:o,AcpSessionResumeCommand:p,AcpSessionStopCommand:s,AcpPromptTurnCommand:i,AcpToolCallsCommand:n,AcpTerminalExecCommand:a,AcpFsAccessCommand:t},acpCapabilityContracts={AcpTransportCapability:e};export function registerAcpOperations(r){return r.register(o).register(p).register(s).register(i).register(n).register(a).register(t)}export function registerAcpCapabilities(r){return r.register(e)}

package/dist/node/acp/index.js

@@ -0,0 +1 @@
+export*from"./acp.feature.js";export*from"./capabilities/index.js";export*from"./commands/index.js";export*from"./constants.js";export*from"./contracts.js";