@makaio/framework 1.0.0-dev-1783282710723 → 1.0.0-dev-1783439621927

package/dist/{index-gAFwNiJT.d.mts → index-BvTd61i5.d.mts}

@@ -87,6 +87,8 @@ declare class Turn$1 {
   private readonly _agentIds;
   /** Messages sent during this turn */
   private readonly _messageIds;
+  /** Message IDs currently claiming this turn while their storage append is in-flight. */
+  private readonly _pendingMessageAppends;
   /** Agents that have completed successfully */
   private readonly _completedAgents;
   /** Agents that errored (agentId → error message) */
@@ -108,6 +110,11 @@ declare class Turn$1 {
    * @returns Immutable array of message IDs
    */
   get messageIds(): readonly string[];
+  /**
+   * Whether a user message has claimed this turn before its storage append completes.
+   * @returns True when at least one message append is in-flight
+   */
+  get hasPendingMessageAppends(): boolean;
   /**
    * Agents that have completed successfully.
    * @returns Read-only set of completed agent IDs
@@ -123,6 +130,16 @@ declare class Turn$1 {
    * @param messageId - The message ID to add
    */
   addMessage(messageId: string): void;
+  /**
+   * Claim this turn for a message whose durable append has started.
+   * @param messageId - Message ID whose append is in-flight
+   */
+  claimMessageAppend(messageId: string): void;
+  /**
+   * Release a failed message append claim without adding the message.
+   * @param messageId - Message ID whose append failed
+   */
+  releaseMessageAppend(messageId: string): void;
   /**
    * Mark an agent as completed successfully.
    * @param agentId - The agent that completed
@@ -165,6 +182,12 @@ declare class Turn$1 {
    * @returns Turn context with turnId and the specified messageId
    */
   getContextForMessage(messageId: string): TurnContext;
+  /**
+   * Return the recorded terminal outcome for an agent, if any.
+   * @param agentId - Agent ID to inspect.
+   * @returns Terminal outcome already recorded for the agent.
+   */
+  private getAgentTerminalOutcome;
   /**
    * Check if turn should complete and return appropriate state change.
    * @returns State change indicating completion status and result if complete
@@ -201,15 +224,29 @@ type TurnCompleteCallback = (turn: Turn$1, result: TurnCompletionResult) => Prom
  * `TurnStorageSubjects.create` is unhandled, synthetic IDs are generated
  * locally. When `TurnStorageSubjects.complete` is unhandled, the turn is
  * still cleared from memory and `session.turn.completed` is emitted.
+ *
+ * **Persist-before-emit barrier:** `session.turn.completed` promises the
+ * four-point consumer contract, including messages being queryable via
+ * `storage:message.getByTurn`. Message persistence (SessionBridge) and turn
+ * completion both react to `agent.complete`, and the bus runs event handlers
+ * in parallel — so before emitting, `completeTurn` awaits
+ * `storage:message.stored` confirmations for the turn's assistant messages
+ * (bus-mediated: the manager holds no reference to SessionBridge). The wait
+ * is bounded by {@link TURN_COMPLETION_PERSISTENCE_TIMEOUT_MS} and skipped
+ * entirely in ephemeral mode.
  */
 declare class SessionTurnManager {
   private readonly bus;
   /** Active turns keyed by sessionId (one turn per session). */
   private readonly activeTurns;
-  /** Per-session usage accumulators, parallel to activeTurns. */
+  /** Per-turn usage accumulators, keyed by turnId. */
   private readonly usageAccumulators;
-  /** Sessions currently persisting turn completion (prevents concurrent writes). */
-  private readonly completingSessions;
+  /** Turns currently persisting completion (prevents concurrent writes). */
+  private readonly completingTurnIds;
+  /** Completing turns retained for usage correlation after active routing is cleared. */
+  private readonly completingTurns;
+  /** Pending terminal completions keyed by turnId; value records whether turn storage handled the transition. */
+  private readonly pendingTerminalCompletions;
   /** Usage events received while completion persistence is in-flight. */
   private readonly bufferedUsageDuringCompletion;
   /**
@@ -221,6 +258,18 @@ declare class SessionTurnManager {
    * the counter and cause duplicate turn numbers if the session continues.
    */
   private readonly syntheticTurnCounters;
+  /**
+   * Stored assistant messages per turnId, counted from `storage:message.stored`.
+   *
+   * Populated continuously (from construction) so messages persisted before
+   * `completeTurn` runs are counted. FIFO-capped at
+   * {@link ASSISTANT_PERSISTENCE_COUNTER_CAP}; a turn's entry is deleted when
+   * its completion emits, so late `stored` events for an already-emitted turn
+   * merely recreate a short-lived entry that the cap eventually evicts.
+   */
+  private readonly assistantStoredCounts;
+  /** Pending persist-before-emit barrier waiters, keyed by turnId. */
+  private readonly assistantPersistenceWaiters;
   /** Bus subscription cleanup functions. */
   private readonly cleanups;
   /**
@@ -240,6 +289,28 @@ declare class SessionTurnManager {
    * @returns The newly created and activated Turn entity
    */
   createTurn(sessionId: string, agentIds: string[], initiator?: TurnInitiator, turnId?: string): Promise<Turn$1>;
+  /**
+   * Discard active in-memory state for a turn that failed before routing began.
+   *
+   * Use when no durable turn row needs a terminal status transition.
+   * @param turn - Newly created active turn to discard
+   */
+  discardActiveTurn(turn: Turn$1): void;
+  /**
+   * Mark an unclaimed newly created turn as failed and discard its active in-memory state.
+   *
+   * This preserves the durable turn lifecycle invariant when setup fails after
+   * `storage:turn.create` has already assigned a turn number.
+   * @param turn - Newly created active turn whose setup failed before any message claimed it
+   * @param error - Durable error code to store on the terminal turn
+   */
+  failActiveTurnSetup(turn: Turn$1, error: string): Promise<void>;
+  /**
+   * Remove a turn from the active routing index when it is no longer routable.
+   * @param turn - Turn to remove when it still owns the session slot
+   * @returns Whether the turn owned and cleared the active routing slot
+   */
+  private clearActiveRoutingTurn;
   /**
    * Register bus listeners for `agent.usage` and `agent.complete` events.
    *
@@ -260,10 +331,22 @@ declare class SessionTurnManager {
    * `TurnStorageSubjects.complete` call. State is cleared only after durable
    * persistence succeeds; if persistence fails, the state remains intact so
    * completion can be retried.
+   *
+   * Before the event fires, the persist-before-emit barrier waits for the
+   * turn's assistant messages to be stored (see class docs), then a
+   * `turn.completed` lifecycle row is appended to `session_events` — so both
+   * message rows and the lifecycle row are durable before consumers observe
+   * `session.turn.completed`.
    * @param turn - The turn to complete
    * @param result - Turn result (success status and error messages)
    */
   completeTurn(turn: Turn$1, result: TurnCompletionResult): Promise<void>;
+  /**
+   * Clear in-memory state retained only while a turn completion is in progress.
+   * @param turn - Turn whose completion state should be removed
+   * @param usageAccumulator - Optional accumulator retained for late usage merges
+   */
+  private clearCompletionState;
   /**
    * Get the active turn for a session, if any.
    * @param sessionId - Session identifier
@@ -303,14 +386,85 @@ declare class SessionTurnManager {
    * @param success - Whether the agent completed successfully
    * @param error - Error message if the agent failed
    * @param onTurnComplete - Callback to invoke when the turn is complete
+   * @param completionTurnId - Turn identifier supplied by the adapter completion event
    */
   private handleAgentCompletion;
   /**
    * Buffer a usage event that arrived while turn completion persistence is in-flight.
-   * @param sessionId - Session whose turn is currently completing
+   * @param turnId - Turn whose completion is currently being persisted
    * @param usageEvent - Usage event to defer until after persistence
    */
   private bufferUsageDuringCompletion;
+  /**
+   * Find a turn that may still accept usage by turnId.
+   * @param turnId - Turn identifier from an agent usage event
+   * @returns Active or completing turn, if usage can still be recorded
+   */
+  private findTurnForUsage;
+  /**
+   * Find a turn that may still accept agent completion by turnId.
+   * @param turnId - Turn identifier from an agent completion event
+   * @returns Active or completing turn, if completion can still be correlated
+   */
+  private findTurnForCompletion;
+  /**
+   * Find the active turn for a legacy completion event without turnId.
+   * @param agentId - Agent ID from the completion event.
+   * @returns Active turn to mutate, or undefined when the event is ambiguous.
+   */
+  private findTurnForUncorrelatedCompletion;
+  /**
+   * Check whether a terminal outcome has already been recorded for an agent.
+   * @param turn - Turn being completed.
+   * @param agentId - Agent ID from the terminal event.
+   * @returns Whether the agent already has a terminal outcome on the turn.
+   */
+  private hasTerminalOutcome;
+  /**
+   * Persist a turn's terminal status and optional usage snapshot.
+   * @param turn - Turn being completed
+   * @param result - Completion result to persist
+   * @param usage - Usage snapshot to include, when available
+   * @param expectedStatus - Optional status guard for the first terminal transition
+   * @returns Whether turn storage handled the request and terminalized the turn
+   */
+  private persistTurnCompletion;
+  /**
+   * Merge buffered usage and persist the updated snapshot.
+   * @param turn - Turn whose buffered usage should be merged
+   * @param result - Completion result for the turn
+   * @param usageAccumulator - Usage accumulator captured by the completing turn
+   * @param currentUsage - Current completed usage snapshot
+   * @returns Updated usage snapshot
+   */
+  private flushBufferedUsageDuringCompletion;
+  /**
+   * Subscribe to `storage:message.stored` and count stored assistant messages
+   * per turnId, resolving any pending barrier waiter on each increment.
+   *
+   * Registered from the constructor (not `registerCompletionHandlers`) so the
+   * barrier also works for callers that drive `completeTurn` directly without
+   * wiring the agent-event handlers.
+   */
+  private registerAssistantPersistenceCounter;
+  /**
+   * Persist-before-emit barrier: wait until the turn's assistant messages are
+   * durably stored (one per agent) or the bounded timeout elapses.
+   *
+   * Resolution paths, in order:
+   * 1. The continuous `storage:message.stored` counter already reached the
+   *    expected count (messages stored before `completeTurn` ran).
+   * 2. `storage:message.getByTurn` is unhandled — no message storage exists,
+   *    nothing can be waited for (skip).
+   * 3. A queryable-state probe already shows the expected assistant messages
+   *    (covers messages persisted before this manager was constructed).
+   * 4. A waiter resolved by the counter reaching the expected count, bounded
+   *    by {@link TURN_COMPLETION_PERSISTENCE_TIMEOUT_MS} — the timeout is
+   *    mandatory because SessionBridge persists nothing for agents with zero
+   *    blocks and no error, and swallows write errors.
+   * @param turn - The completing turn (expected count = its agent count)
+   */
+  private awaitAssistantPersistence;
 }
 //#endregion
 //#region services/core/src/session/handlers/abandon-handler.d.ts
@@ -359,9 +513,10 @@ declare function registerCompressHandler(bus: IMakaioBus): () => void;
  * Creates a new session with parent reference. The forked session starts
  * empty - its full conversation is assembled by traversing the parent chain.
  * @param bus - Bus instance for communication
+ * @param machineId - Stable runtime machine identity to stamp on child sessions
  * @returns Cleanup function to unsubscribe
  */
-declare function registerForkHandler(bus: IMakaioBus): () => void;
+declare function registerForkHandler(bus: IMakaioBus, machineId?: string): () => void;
 //#endregion
 //#region services/core/src/session/handlers/merge-handler.d.ts
 /**
@@ -385,6 +540,50 @@ interface CwdSwapMeta {
   previousCwd: string;
   newCwd: string;
 }
+/**
+ * Options for routing a message to target agents.
+ */
+interface RouteToAgentsOptions {
+  /** Bus instance for communication. */
+  readonly bus: IMakaioBus;
+  /** Session metadata (for fork detection). */
+  readonly session: IMakaioSession;
+  /** Target agents to route to. */
+  readonly agents: MakaioSessionAgent[];
+  /** Message content to send. */
+  readonly message: MessageInput;
+  /** Message identifier. */
+  readonly messageId: string;
+  /** Turn tracking object. */
+  readonly turn: Turn$1;
+  /** How to deliver the message. */
+  readonly deliveryMode: 'enqueue' | 'immediate' | undefined;
+  /** Callback when turn completes (all agents done). */
+  readonly onTurnComplete: (turn: Turn$1, result: {
+    success: boolean;
+    errors: string[];
+  }) => Promise<void>;
+  /** Session context with curated messageHistory and decision signals. */
+  readonly sessionContext?: SessionContext;
+  /** Optional enricher for immediate message context. */
+  readonly turnContextEnricher?: ITurnContextEnricher;
+  /** Whether this is the first message in a new turn. */
+  readonly isNewTurn?: boolean;
+  /** Context enriched with messageHistory for agents that were just recovered. */
+  readonly recoveryContext?: SessionContext;
+  /** Set of agent IDs that were recovered in this handler invocation. */
+  readonly recoveredAgentIds?: ReadonlySet<string>;
+  /** Set of agent IDs that swapped connector due to cwd mismatch. */
+  readonly swappedAgentIds?: ReadonlySet<string>;
+  /** Previous/new cwd metadata keyed by agent ID. */
+  readonly swappedAgentCwd?: ReadonlyMap<string, CwdSwapMeta>;
+  /** Curated history for agents forced into fresh mode. */
+  readonly freshMessageHistory?: Message[];
+  /** Optional structured output descriptor for the turn. */
+  readonly responseSchema?: ResponseSchemaDescriptor;
+  /** Stable machine identity of the current host process for locality evaluation. */
+  readonly localMachineId?: string;
+}
 /**
  * Route a message to target agents via agent.sendMessage.
  *
@@ -392,28 +591,9 @@ interface CwdSwapMeta {
  * and checks for turn completion.
  *
  * For fork sessions on their first turn, assembles projected context from parent chain.
- * @param bus - Bus instance for communication
- * @param session - Session metadata (for fork detection)
- * @param agents - Target agents to route to
- * @param message - Message content to send
- * @param messageId - Message identifier
- * @param turn - Turn tracking object
- * @param deliveryMode - How to deliver the message
- * @param onTurnComplete - Callback when turn completes (all agents done)
- * @param sessionContext - Session context with curated messageHistory and decision signals
- * @param turnContextEnricher - Optional enricher for immediate message context
- * @param isNewTurn - Whether this is the first message in a new turn
- * @param recoveryContext - Context enriched with messageHistory for agents that were just recovered
- * @param recoveredAgentIds - Set of agent IDs that were recovered in this handler invocation
- * @param swappedAgentIds - Set of agent IDs that swapped connector due to cwd mismatch
- * @param swappedAgentCwd - Previous/new cwd metadata keyed by agent ID
- * @param freshMessageHistory - Curated history for agents forced into fresh mode
- * @param responseSchema - Optional structured output descriptor for the turn
+ * @param options - Routing options including bus, session, agents, message, and lifecycle dependencies
  */
-declare function routeToAgents(bus: IMakaioBus, session: IMakaioSession, agents: MakaioSessionAgent[], message: MessageInput, messageId: string, turn: Turn$1, deliveryMode: 'enqueue' | 'immediate' | undefined, onTurnComplete: (turn: Turn$1, result: {
-  success: boolean;
-  errors: string[];
-}) => Promise<void>, sessionContext?: SessionContext, turnContextEnricher?: ITurnContextEnricher, isNewTurn?: boolean, recoveryContext?: SessionContext, recoveredAgentIds?: ReadonlySet<string>, swappedAgentIds?: ReadonlySet<string>, swappedAgentCwd?: ReadonlyMap<string, CwdSwapMeta>, freshMessageHistory?: Message[], responseSchema?: ResponseSchemaDescriptor): Promise<void>;
+declare function routeToAgents(options: RouteToAgentsOptions): Promise<void>;
 //#endregion
 //#region services/core/src/session/handlers/route-to-agents-core.d.ts
 /**
@@ -422,6 +602,12 @@ declare function routeToAgents(bus: IMakaioBus, session: IMakaioSession, agents:
  * Fans out to all agents in parallel. On routing failure, marks the agent
  * as errored and checks for turn completion. On `HookAbortError`, marks
  * the agent as completed with `cancelled` outcome.
+ *
+ * Contract: `sessionContext` must not carry a `nativeFork` directive. This
+ * function dispatches exclusively via `agent.sendMessage`, which never
+ * consumes the directive — fork directives are consumed only on the
+ * `startAgent` path. Callers assembling fork contexts must degrade them to
+ * fresh-with-history first (see `routeToAgents`).
  * @param bus - Bus instance for communication
  * @param session - Session metadata (for session ID)
  * @param agents - Target agents to route to

package/dist/{index-Y2r0Zvcm.d.mts → index-BvjLe_w9.d.mts}

@@ -140,17 +140,16 @@ declare const HarnessDefinitionCreateSchema: z.ZodObject<{
   cwd: z.ZodOptional<z.ZodString>;
   env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
   name: z.ZodString;
-  adapterName: z.ZodOptional<z.ZodString>;
   nativeTools: z.ZodObject<{
     enabled: z.ZodArray<z.ZodString>;
     disabled: z.ZodArray<z.ZodString>;
   }, z.core.$strip>;
-  clientId: z.ZodOptional<z.ZodString>;
-  credentials: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
   registryTools: z.ZodObject<{
     enabled: z.ZodArray<z.ZodString>;
     disabled: z.ZodArray<z.ZodString>;
   }, z.core.$strip>;
+  adapterName: z.ZodOptional<z.ZodString>;
+  clientId: z.ZodOptional<z.ZodString>;
   skills: z.ZodOptional<z.ZodObject<{
     enabled: z.ZodArray<z.ZodString>;
     disabled: z.ZodArray<z.ZodString>;
@@ -176,6 +175,7 @@ declare const HarnessDefinitionCreateSchema: z.ZodObject<{
     "always-ask": "always-ask";
     "full-access": "full-access";
   }>>>;
+  credentials: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
   approvalPolicy: z.ZodOptional<z.ZodEnum<{
     reject: "reject";
     "always-ask": "always-ask";
@@ -316,17 +316,16 @@ declare const HarnessSchemas: {
       cwd: z.ZodOptional<z.ZodString>;
       env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
       name: z.ZodString;
-      adapterName: z.ZodOptional<z.ZodString>;
       nativeTools: z.ZodObject<{
         enabled: z.ZodArray<z.ZodString>;
         disabled: z.ZodArray<z.ZodString>;
       }, z.core.$strip>;
-      clientId: z.ZodOptional<z.ZodString>;
-      credentials: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
       registryTools: z.ZodObject<{
         enabled: z.ZodArray<z.ZodString>;
         disabled: z.ZodArray<z.ZodString>;
       }, z.core.$strip>;
+      adapterName: z.ZodOptional<z.ZodString>;
+      clientId: z.ZodOptional<z.ZodString>;
       skills: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodArray<z.ZodString>;
         disabled: z.ZodArray<z.ZodString>;
@@ -352,6 +351,7 @@ declare const HarnessSchemas: {
         "always-ask": "always-ask";
         "full-access": "full-access";
       }>>>;
+      credentials: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
       approvalPolicy: z.ZodOptional<z.ZodEnum<{
         reject: "reject";
         "always-ask": "always-ask";
@@ -759,17 +759,16 @@ declare const HarnessNamespace: _$_makaio_core0.BusNamespaceDefinition<"harness"
       cwd: z.ZodOptional<z.ZodString>;
       env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
       name: z.ZodString;
-      adapterName: z.ZodOptional<z.ZodString>;
       nativeTools: z.ZodObject<{
         enabled: z.ZodArray<z.ZodString>;
         disabled: z.ZodArray<z.ZodString>;
       }, z.core.$strip>;
-      clientId: z.ZodOptional<z.ZodString>;
-      credentials: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
       registryTools: z.ZodObject<{
         enabled: z.ZodArray<z.ZodString>;
         disabled: z.ZodArray<z.ZodString>;
       }, z.core.$strip>;
+      adapterName: z.ZodOptional<z.ZodString>;
+      clientId: z.ZodOptional<z.ZodString>;
       skills: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodArray<z.ZodString>;
         disabled: z.ZodArray<z.ZodString>;
@@ -795,6 +794,7 @@ declare const HarnessNamespace: _$_makaio_core0.BusNamespaceDefinition<"harness"
         "always-ask": "always-ask";
         "full-access": "full-access";
       }>>>;
+      credentials: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
       approvalPolicy: z.ZodOptional<z.ZodEnum<{
         reject: "reject";
         "always-ask": "always-ask";
@@ -1202,17 +1202,16 @@ declare const HarnessSubjects: _$_makaio_core0.BusSubjects<_$_makaio_core0.FlatS
       cwd: z.ZodOptional<z.ZodString>;
       env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
       name: z.ZodString;
-      adapterName: z.ZodOptional<z.ZodString>;
       nativeTools: z.ZodObject<{
         enabled: z.ZodArray<z.ZodString>;
         disabled: z.ZodArray<z.ZodString>;
       }, z.core.$strip>;
-      clientId: z.ZodOptional<z.ZodString>;
-      credentials: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
       registryTools: z.ZodObject<{
         enabled: z.ZodArray<z.ZodString>;
         disabled: z.ZodArray<z.ZodString>;
       }, z.core.$strip>;
+      adapterName: z.ZodOptional<z.ZodString>;
+      clientId: z.ZodOptional<z.ZodString>;
       skills: z.ZodOptional<z.ZodObject<{
         enabled: z.ZodArray<z.ZodString>;
         disabled: z.ZodArray<z.ZodString>;
@@ -1238,6 +1237,7 @@ declare const HarnessSubjects: _$_makaio_core0.BusSubjects<_$_makaio_core0.FlatS
         "always-ask": "always-ask";
         "full-access": "full-access";
       }>>>;
+      credentials: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
       approvalPolicy: z.ZodOptional<z.ZodEnum<{
         reject: "reject";
         "always-ask": "always-ask";

package/dist/{index-2fK9iSHI.d.mts → index-BwGfdbI0.d.mts}

@@ -48,8 +48,8 @@ declare const MaterializationSchemas: {
         template: z.ZodString;
       }, z.core.$strip>], "kind">;
       appliesTo: z.ZodArray<z.ZodEnum<{
-        artifact: "artifact";
         workpiece: "workpiece";
+        artifact: "artifact";
         surface: "surface";
       }>>;
       valueMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -88,8 +88,8 @@ declare const MaterializationSchemas: {
           template: z.ZodString;
         }, z.core.$strip>], "kind">;
         appliesTo: z.ZodArray<z.ZodEnum<{
-          artifact: "artifact";
           workpiece: "workpiece";
+          artifact: "artifact";
           surface: "surface";
         }>>;
         valueMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -106,8 +106,8 @@ declare const MaterializationSchemas: {
     provider: z.ZodString;
     externalId: z.ZodString;
     operation: z.ZodEnum<{
-      deleted: "deleted";
       upserted: "upserted";
+      deleted: "deleted";
     }>;
   }, z.core.$strip>; /** Emitted when a provider surface capability set has been resolved. */
   'capability.resolved': z.ZodObject<{
@@ -153,8 +153,8 @@ declare const MaterializationNamespace: _$_makaio_core0.BusNamespaceDefinition<"
         template: z.ZodString;
       }, z.core.$strip>], "kind">;
       appliesTo: z.ZodArray<z.ZodEnum<{
-        artifact: "artifact";
         workpiece: "workpiece";
+        artifact: "artifact";
         surface: "surface";
       }>>;
       valueMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -193,8 +193,8 @@ declare const MaterializationNamespace: _$_makaio_core0.BusNamespaceDefinition<"
           template: z.ZodString;
         }, z.core.$strip>], "kind">;
         appliesTo: z.ZodArray<z.ZodEnum<{
-          artifact: "artifact";
           workpiece: "workpiece";
+          artifact: "artifact";
           surface: "surface";
         }>>;
         valueMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -211,8 +211,8 @@ declare const MaterializationNamespace: _$_makaio_core0.BusNamespaceDefinition<"
     provider: z.ZodString;
     externalId: z.ZodString;
     operation: z.ZodEnum<{
-      deleted: "deleted";
       upserted: "upserted";
+      deleted: "deleted";
     }>;
   }, z.core.$strip>; /** Emitted when a provider surface capability set has been resolved. */
   'capability.resolved': z.ZodObject<{
@@ -268,8 +268,8 @@ declare const MaterializationSubjects: _$_makaio_core0.BusSubjects<_$_makaio_cor
         template: z.ZodString;
       }, z.core.$strip>], "kind">;
       appliesTo: z.ZodArray<z.ZodEnum<{
-        artifact: "artifact";
         workpiece: "workpiece";
+        artifact: "artifact";
         surface: "surface";
       }>>;
       valueMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -308,8 +308,8 @@ declare const MaterializationSubjects: _$_makaio_core0.BusSubjects<_$_makaio_cor
           template: z.ZodString;
         }, z.core.$strip>], "kind">;
         appliesTo: z.ZodArray<z.ZodEnum<{
-          artifact: "artifact";
           workpiece: "workpiece";
+          artifact: "artifact";
           surface: "surface";
         }>>;
         valueMapping: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -326,8 +326,8 @@ declare const MaterializationSubjects: _$_makaio_core0.BusSubjects<_$_makaio_cor
     provider: z.ZodString;
     externalId: z.ZodString;
     operation: z.ZodEnum<{
-      deleted: "deleted";
       upserted: "upserted";
+      deleted: "deleted";
     }>;
   }, z.core.$strip>; /** Emitted when a provider surface capability set has been resolved. */
   'capability.resolved': z.ZodObject<{

package/dist/{index-CaOWqztb.d.mts → index-C8k2f_E0.d.mts}

@@ -1,5 +1,5 @@
 import { i as CliContribution } from "./types-DCvp_swt.mjs";
-import { c as ExtensionInfo } from "./index-Bh6lHiW4.mjs";
+import { c as ExtensionInfo } from "./index-B5Uczo3R.mjs";
 import { r as WindowRegistry } from "./window-registry-ofIUQnfo.mjs";
 import { IMakaioBus } from "@makaio/framework/bus";
 import { ExtensionContributionProcessor, ExtensionService, ExtensionToken, MakaioExtension, NodeExtensionContext, StorageDialect, TrayManifest, VersionLiteral } from "@makaio/framework/contracts";

package/dist/{index-DEzdNQum.d.mts → index-CYHWOXUm.d.mts}

@@ -9,8 +9,8 @@ import { z } from "zod";
  * - `visible` — Model is usable and shown in the AgentPicker UI.
  */
 declare const ModelVisibilitySchema: z.ZodEnum<{
-  disabled: "disabled";
   enabled: "enabled";
+  disabled: "disabled";
   visible: "visible";
 }>;
 type ModelVisibility = z.infer<typeof ModelVisibilitySchema>;