@jmanuelcorral/openteam 0.2.2 → 0.9.0

package/dist/orchestrator/ralphLoop.d.ts

@@ -0,0 +1,57 @@
+import type { OpenTeamConfig } from "../config/schema";
+import type { RoutingDecision, TaskSignals } from "../router/types";
+import { type CoordinatorDeps, type RoleTaskResult } from "./coordinator";
+/**
+ * W3 ralph loop (#174).
+ *
+ * Makes the guaranteed `ralph` role a real behaviour rather than an unreachable
+ * profile: a bounded iterate-until-done cycle. Each pass dispatches the `ralph`
+ * role through the real coordinator ({@link runRoleTask}), so the loop inherits
+ * two guarantees for free — the mandatory-local gate (#143), which refuses to run
+ * BEFORE the first iteration when no local runtime is reachable and never falls
+ * through to a frontier provider, and local-first routing, which keeps every
+ * iteration on a local runtime.
+ *
+ * This module is only loop CONTROL: model/runtime work is the injected coordinator
+ * deps, and the done-signal is an injected predicate. Deterministic given its
+ * ports — no clock, randomness or direct I/O.
+ */
+/** Canonical roleID of the guaranteed ralph role. */
+export declare const RALPH_ROLE_ID = "ralph";
+/** Default iteration cap so the loop can never spin unbounded. */
+export declare const DEFAULT_RALPH_MAX_ITERATIONS = 10;
+export type RalphLoopInput = {
+    readonly task: TaskSignals;
+    readonly prompt: string;
+    readonly config: OpenTeamConfig;
+    readonly parentSessionID?: string;
+    /** Iteration cap; defaults to {@link DEFAULT_RALPH_MAX_ITERATIONS}. */
+    readonly maxIterations?: number;
+};
+/** Why the loop stopped: the done-signal fired, or the iteration cap was hit. */
+export type RalphLoopTermination = "done" | "cap";
+export type RalphLoopResult = {
+    readonly iterations: number;
+    readonly termination: RalphLoopTermination;
+    readonly decision: RoutingDecision | undefined;
+    readonly results: readonly RoleTaskResult[];
+};
+export type RalphLoopDeps = CoordinatorDeps & {
+    /**
+     * The done-signal predicate (#174). Reads the iteration's subsession result and
+     * decides whether the task is finished. Injected so the "fake runtime" that
+     * reports done/not-done stays outside the loop control under test.
+     */
+    readonly isDone: (result: RoleTaskResult) => boolean;
+};
+/**
+ * Runs the ralph loop (#174): dispatches the `ralph` role repeatedly until the
+ * injected done-signal fires or the iteration cap is reached.
+ *
+ * On the first pass, {@link runRoleTask} enforces the mandatory-local gate: when
+ * no local runtime is reachable it throws before any dispatch, so the loop fails
+ * before the first iteration and no model is contacted — the caller sees the
+ * thrown, actionable error.
+ */
+export declare function runRalphLoop(input: RalphLoopInput, deps: RalphLoopDeps): Promise<RalphLoopResult>;
+//# sourceMappingURL=ralphLoop.d.ts.map

package/dist/orchestrator/ralphLoop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ralphLoop.d.ts","sourceRoot":"","sources":["../../src/orchestrator/ralphLoop.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,KAAK,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AACpE,OAAO,EACL,KAAK,eAAe,EAEpB,KAAK,cAAc,EAEpB,MAAM,eAAe,CAAC;AAEvB;;;;;;;;;;;;;;GAcG;AAEH,qDAAqD;AACrD,eAAO,MAAM,aAAa,UAAU,CAAC;AAErC,kEAAkE;AAClE,eAAO,MAAM,4BAA4B,KAAK,CAAC;AAE/C,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,eAAe,CAAC,EAAE,MAAM,CAAC;IAClC,uEAAuE;IACvE,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;CACjC,CAAC;AAEF,iFAAiF;AACjF,MAAM,MAAM,oBAAoB,GAAG,MAAM,GAAG,KAAK,CAAC;AAElD,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,WAAW,EAAE,oBAAoB,CAAC;IAC3C,QAAQ,CAAC,QAAQ,EAAE,eAAe,GAAG,SAAS,CAAC;IAC/C,QAAQ,CAAC,OAAO,EAAE,SAAS,cAAc,EAAE,CAAC;CAC7C,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,eAAe,GAAG;IAC5C;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,CAAC,MAAM,EAAE,cAAc,KAAK,OAAO,CAAC;CACtD,CAAC;AAeF;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CAChC,KAAK,EAAE,cAAc,EACrB,IAAI,EAAE,aAAa,GAClB,OAAO,CAAC,eAAe,CAAC,CA+B1B"}

package/dist/orchestrator/roles.d.ts

@@ -1,5 +1,6 @@
 import { z } from "zod";
 import type { CapabilityRequirement, ComplexityTier } from "../capabilities/types";
+import type { LocalRuntimeId } from "../local/types";
 import type { ModelSelection, TaskSignals } from "../router/types";
 export type AgentRoleProfile = {
     roleID: string;
@@ -8,9 +9,34 @@ export type AgentRoleProfile = {
     minReasoningTier: 1 | 2 | 3 | 4 | 5;
     minCodeQualityTier: 1 | 2 | 3 | 4 | 5;
     needsToolCallingByDefault: boolean;
-    preferredLocalModels: ModelSelection[];
     preferredFrontierModels: Array<ModelSelection | "auto">;
     localFirst: boolean;
+    /**
+     * Hard requirement that this role runs on a reachable LOCAL runtime (#143).
+     *
+     * This is a PROHIBITION, distinct from the `localFirst` PREFERENCE. `localFirst`
+     * only tilts routing toward local and still falls through to frontier when no
+     * local runtime is reachable (2026-08-26 ruling). `requiresLocalRuntime` refuses
+     * the request before dispatch when no local runtime is reachable — it never
+     * falls through to a frontier provider. Optional so existing roles keep today's
+     * behaviour; only bookkeeping/safety roles (scribe, ralph, guardian) set it `true`.
+     */
+    requiresLocalRuntime?: boolean;
+    /**
+     * Ordered preference list of LOCAL runtimes this role may draw on (#144).
+     *
+     * When set, dispatch walks the list in order and picks the FIRST runtime that
+     * is reachable; an unreachable runtime is skipped (failover). The chosen
+     * runtime is then honoured for the whole task — capacity is enforced on it and
+     * excess work queues rather than spilling to a less-preferred runtime. When
+     * `requiresLocalRuntime` is also set, the hard requirement is satisfied when
+     * ANY listed runtime is reachable; when none is, the role fails closed.
+     *
+     * Optional so existing roles keep today's behaviour: without a list, the role
+     * dispatches to whatever local model routing selected, with capacity enforced
+     * on that runtime.
+     */
+    localRuntimes?: LocalRuntimeId[];
 };
 export declare const AgentRoleProfileSchema: z.ZodObject<{
     roleID: z.ZodString;
@@ -24,17 +50,33 @@ export declare const AgentRoleProfileSchema: z.ZodObject<{
     minReasoningTier: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>]>;
     minCodeQualityTier: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>, z.ZodLiteral<3>, z.ZodLiteral<4>, z.ZodLiteral<5>]>;
     needsToolCallingByDefault: z.ZodBoolean;
-    preferredLocalModels: z.ZodArray<z.ZodObject<{
-        providerID: z.ZodString;
-        modelID: z.ZodString;
-    }, z.core.$strip>>;
     preferredFrontierModels: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
         providerID: z.ZodString;
         modelID: z.ZodString;
-    }, z.core.$strip>, z.ZodLiteral<"auto">]>>;
+    }, z.core.$strict>, z.ZodLiteral<"auto">]>>;
     localFirst: z.ZodBoolean;
-}, z.core.$strip>;
+    requiresLocalRuntime: z.ZodOptional<z.ZodBoolean>;
+    localRuntimes: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        "foundry-local": "foundry-local";
+        lemonade: "lemonade";
+        lmstudio: "lmstudio";
+        ollama: "ollama";
+    }>>>;
+}, z.core.$strict>;
 export declare const TEAM_ROLES: Record<string, AgentRoleProfile>;
-export declare function getRoleProfile(roleID: string): AgentRoleProfile | undefined;
+export declare function getRoleProfile(roleID: string, configuredRoles?: Readonly<Record<string, AgentRoleProfile>>): AgentRoleProfile | undefined;
+/**
+ * Synthesises a neutral, frontier-eligible fallback profile for a roleID that
+ * is not present in TEAM_ROLES. The roleID is passed through verbatim so the
+ * orchestrator dispatches the correct agent name to opencode, producing an
+ * accurate error ("agent Galadriel not found") rather than a misleading one
+ * ("agent scribe not found") when the agent does not exist in the workspace.
+ *
+ * Profile values mirror the majority of the team (yen/basher/reviewer):
+ * moderate tier with frontier escalation enabled and local-first routing, so
+ * the core local-first promise is preserved while unknown roles are never
+ * silently starved of frontier access.
+ */
+export declare function synthesiseFallbackProfile(roleID: string): AgentRoleProfile;
 export declare function roleToRequirement(role: AgentRoleProfile, task: TaskSignals, tier?: ComplexityTier): CapabilityRequirement;
 //# sourceMappingURL=roles.d.ts.map

package/dist/orchestrator/roles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"roles.d.ts","sourceRoot":"","sources":["../../src/orchestrator/roles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EACV,qBAAqB,EACrB,cAAc,EACf,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,cAAc,CAAC;IAC5B,gBAAgB,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACpC,kBAAkB,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACtC,yBAAyB,EAAE,OAAO,CAAC;IACnC,oBAAoB,EAAE,cAAc,EAAE,CAAC;IACvC,uBAAuB,EAAE,KAAK,CAAC,cAAc,GAAG,MAAM,CAAC,CAAC;IACxD,UAAU,EAAE,OAAO,CAAC;CACrB,CAAC;AAeF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;iBAYjC,CAAC;AAGH,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAgFvD,CAAC;AAEF,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,GAAG,SAAS,CAE3E;AAED,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,gBAAgB,EACtB,IAAI,EAAE,WAAW,EACjB,IAAI,CAAC,EAAE,cAAc,GACpB,qBAAqB,CAevB"}
+{"version":3,"file":"roles.d.ts","sourceRoot":"","sources":["../../src/orchestrator/roles.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAGxB,OAAO,KAAK,EACV,qBAAqB,EACrB,cAAc,EACf,MAAM,uBAAuB,CAAC;AAC/B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,cAAc,CAAC;IAC5B,gBAAgB,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACpC,kBAAkB,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACtC,yBAAyB,EAAE,OAAO,CAAC;IACnC,uBAAuB,EAAE,KAAK,CAAC,cAAc,GAAG,MAAM,CAAC,CAAC;IACxD,UAAU,EAAE,OAAO,CAAC;IACpB;;;;;;;;;OASG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B;;;;;;;;;;;;;OAaG;IACH,aAAa,CAAC,EAAE,cAAc,EAAE,CAAC;CAClC,CAAC;AAiBF,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;kBAkBxB,CAAC;AAGZ,eAAO,MAAM,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,gBAAgB,CA8FvD,CAAC;AAEF,wBAAgB,cAAc,CAC5B,MAAM,EAAE,MAAM,EACd,eAAe,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,GAC3D,gBAAgB,GAAG,SAAS,CAE9B;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,CAW1E;AAED,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,gBAAgB,EACtB,IAAI,EAAE,WAAW,EACjB,IAAI,CAAC,EAAE,cAAc,GACpB,qBAAqB,CAevB"}

package/dist/orchestrator/roster.d.ts

@@ -0,0 +1,103 @@
+import { z } from "zod";
+/**
+ * W3 roster model (#171, #172).
+ *
+ * The roster is a STRUCTURED artifact, never free LLM prose: a chosen `universe`
+ * plus a list of `roleID` → `agentName` entries. The split (decision P6(a)) keeps
+ * routing keyed to the stable `roleID` (which resolves to a capability profile via
+ * {@link getRoleProfile}) while the themed `agentName` is only the dispatch alias
+ * opencode sees. Validating the artifact with Zod removes the silent-no-op failure
+ * class of a prose parser.
+ *
+ * This module is pure: no I/O, clock, or randomness. Generation takes an injected
+ * {@link RosterSource} port so the model call stays outside the decision core, and
+ * persistence lives in `rosterPersistence.ts`.
+ */
+/** One cast member: a stable routing `roleID` bound to a themed dispatch alias. */
+export declare const RosterEntrySchema: z.ZodObject<{
+    roleID: z.ZodString;
+    agentName: z.ZodString;
+}, z.core.$strict>;
+/** A structured roster: one universe shared by every entry. */
+export declare const RosterSchema: z.ZodObject<{
+    universe: z.ZodString;
+    entries: z.ZodArray<z.ZodObject<{
+        roleID: z.ZodString;
+        agentName: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type RosterEntry = z.infer<typeof RosterEntrySchema>;
+export type Roster = z.infer<typeof RosterSchema>;
+/**
+ * The four roles every roster must contain (#171). `orchestrator` is the primary
+ * agent itself and has no TEAM_ROLES profile; `guardian`/`scribe`/`ralph` are the
+ * bookkeeping/safety roles that carry `requiresLocalRuntime`. Security review,
+ * decision capture and the ralph loop can never be silently omitted from a team.
+ */
+export declare const GUARANTEED_ROLE_IDS: readonly ["orchestrator", "guardian", "scribe", "ralph"];
+export type GuaranteedRoleID = (typeof GUARANTEED_ROLE_IDS)[number];
+/** Guaranteed roleIDs absent from a roster, in canonical order. */
+export declare function missingGuaranteedRoles(roster: Roster): GuaranteedRoleID[];
+/** Whether every guaranteed roleID is present in the roster. */
+export declare function hasAllGuaranteedRoles(roster: Roster): boolean;
+/**
+ * Enforces the guaranteed-role invariant (#171): re-adds any missing guaranteed
+ * role, binding its `agentName` to the canonical roleID so it dispatches to the
+ * standard agent. Returns the roster unchanged when nothing is missing. Pure.
+ */
+export declare function enforceGuaranteedRoles(roster: Roster): Roster;
+/** Draft roster a generator source emits before Zod validation. */
+export type RosterDraft = {
+    universe: string;
+    entries: Array<{
+        roleID: string;
+        agentName: string;
+    }>;
+};
+/**
+ * Injected generation port (#172). Turns an initial prompt into a draft roster.
+ * In production this wraps a model call; tests pass a deterministic fake, so the
+ * generator's decision core never contacts a live LLM.
+ */
+export type RosterSource = (prompt: string) => RosterDraft | Promise<RosterDraft>;
+/**
+ * Generates a roster from the initial prompt (#172): runs the injected source,
+ * validates the draft with Zod (fail-closed on a malformed roster), then enforces
+ * the guaranteed roles (#171). The result is always a valid, guaranteed roster.
+ */
+export declare function generateRoster(prompt: string, source: RosterSource): Promise<Roster>;
+/**
+ * The dispatch target for a roleID: the themed `agentName` opencode dispatches to.
+ * `undefined` when the roleID is not in the roster. This is the roleID/agentName
+ * split at the dispatch boundary — routing uses the roleID, opencode uses this.
+ */
+export declare function rosterDispatchTarget(roster: Roster, roleID: string): string | undefined;
+/**
+ * Resolves the universe an entry belongs to (#172). The universe is recorded ONCE
+ * for the whole roster, so every entry shares the single roster universe; this
+ * throws if the entry is not part of the roster, so the invariant is checked, not
+ * assumed. Pure.
+ */
+export declare function resolveEntryUniverse(roster: Roster, entry: RosterEntry): string;
+/**
+ * Actionable, English failure for a guaranteed role whose agent file was never
+ * written (#153, Defect B). `openteam setup` currently writes only the primary
+ * agent, so `scribe`/`ralph`/`guardian` have no agent file to dispatch to. Names
+ * the missing agent and points at `openteam setup` rather than surfacing an opaque
+ * "agent not found" from opencode.
+ */
+export declare function missingAgentFileMessage(agentName: string): string;
+/**
+ * Fails closed BEFORE dispatch when a guaranteed role's agent file is absent
+ * (#153, Defect B). `agentFileExists` is an injected I/O port — the filesystem
+ * probe lives at the composition root, so this stays pure of I/O.
+ */
+export declare function assertAgentFileForRole(agentName: string, agentFileExists: (agentName: string) => boolean | Promise<boolean>): Promise<void>;
+/**
+ * Dispatches a guaranteed role only after asserting its agent file exists (#153).
+ * The agent-file guard runs BEFORE the `dispatch` callback, so a missing file
+ * surfaces the actionable error without ever contacting a model. `dispatch` is the
+ * real coordinator call the caller supplies.
+ */
+export declare function dispatchGuaranteedRole<T>(agentName: string, agentFileExists: (agentName: string) => boolean | Promise<boolean>, dispatch: () => Promise<T>): Promise<T>;
+//# sourceMappingURL=roster.d.ts.map

package/dist/orchestrator/roster.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roster.d.ts","sourceRoot":"","sources":["../../src/orchestrator/roster.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB;;;;;;;;;;;;;GAaG;AAEH,mFAAmF;AACnF,eAAO,MAAM,iBAAiB;;;kBAKnB,CAAC;AAEZ,+DAA+D;AAC/D,eAAO,MAAM,YAAY;;;;;;kBAKd,CAAC;AAEZ,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAC5D,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAElD;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,YAC9B,cAAc,EACd,UAAU,EACV,QAAQ,EACR,OAAO,CACC,CAAC;AAEX,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEpE,mEAAmE;AACnE,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,gBAAgB,EAAE,CAGzE;AAED,gEAAgE;AAChE,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAE7D;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAU7D;AAED,mEAAmE;AACnE,MAAM,MAAM,WAAW,GAAG;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CACvD,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,YAAY,GAAG,CACzB,MAAM,EAAE,MAAM,KACX,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;AAExC;;;;GAIG;AACH,wBAAsB,cAAc,CAClC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,YAAY,GACnB,OAAO,CAAC,MAAM,CAAC,CAIjB;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb,MAAM,GAAG,SAAS,CAEpB;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,WAAW,GACjB,MAAM,CAOR;AAED;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAMjE;AAED;;;;GAIG;AACH,wBAAsB,sBAAsB,CAC1C,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,GACjE,OAAO,CAAC,IAAI,CAAC,CAIf;AAED;;;;;GAKG;AACH,wBAAsB,sBAAsB,CAAC,CAAC,EAC5C,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,EAClE,QAAQ,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACzB,OAAO,CAAC,CAAC,CAAC,CAGZ"}

package/dist/orchestrator/rosterPersistence.d.ts

@@ -0,0 +1,22 @@
+import type { StorageProvider } from "../storage/provider";
+import { type Roster } from "./roster";
+/** Serialises a roster to the Markdown-with-JSON roster document. Pure. */
+export declare function serializeRoster(roster: Roster): string;
+/** Parses a roster document back into a validated {@link Roster}. Pure. */
+export declare function parseRoster(text: string): Roster;
+/** Writes the roster to the portable path; returns the path written. */
+export declare function persistRoster(storage: StorageProvider, roster: Roster, path?: string): Promise<string>;
+/** Loads and parses the persisted roster; `undefined` when none exists. */
+export declare function loadRoster(storage: StorageProvider, path?: string): Promise<Roster | undefined>;
+/** Outcome of {@link loadOrGenerateRoster}: the roster and whether it was rebuilt. */
+export type RosterLoadResult = {
+    readonly roster: Roster;
+    readonly regenerated: boolean;
+};
+/**
+ * Reuses the persisted cast when present, generating and persisting one only when
+ * absent (#173). A second session with a roster on disk therefore never triggers
+ * re-generation — the cast stays stable across sessions.
+ */
+export declare function loadOrGenerateRoster(storage: StorageProvider, generate: () => Roster | Promise<Roster>, path?: string): Promise<RosterLoadResult>;
+//# sourceMappingURL=rosterPersistence.d.ts.map

package/dist/orchestrator/rosterPersistence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rosterPersistence.d.ts","sourceRoot":"","sources":["../../src/orchestrator/rosterPersistence.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,KAAK,MAAM,EAAgB,MAAM,UAAU,CAAC;AAmBrD,2EAA2E;AAC3E,wBAAgB,eAAe,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAItD;AAED,2EAA2E;AAC3E,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAchD;AAED,wEAAwE;AACxE,wBAAsB,aAAa,CACjC,OAAO,EAAE,eAAe,EACxB,MAAM,EAAE,MAAM,EACd,IAAI,GAAE,MAA6B,GAClC,OAAO,CAAC,MAAM,CAAC,CAGjB;AAED,2EAA2E;AAC3E,wBAAsB,UAAU,CAC9B,OAAO,EAAE,eAAe,EACxB,IAAI,GAAE,MAA6B,GAClC,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAM7B;AAED,sFAAsF;AACtF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,WAAW,EAAE,OAAO,CAAC;CAC/B,CAAC;AAEF;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,eAAe,EACxB,QAAQ,EAAE,MAAM,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,EACxC,IAAI,GAAE,MAA6B,GAClC,OAAO,CAAC,gBAAgB,CAAC,CAQ3B"}

package/dist/orchestrator/runtimeSelection.d.ts

@@ -0,0 +1,46 @@
+import type { OpenTeamConfig } from "../config/schema";
+import type { LocalRuntimeId } from "../local/types";
+import type { ModelSelection, RoutingDecision } from "../router/types";
+import type { AgentRoleProfile } from "./roles";
+/**
+ * Result of resolving which local runtime a role's task dispatches to (#144).
+ *
+ * `runtimeId` is the runtime the task is PINNED to for its whole duration —
+ * capacity is enforced on it and it never changes once chosen. It is `undefined`
+ * when the dispatch is not to a configured local runtime (a frontier route, or a
+ * local model that maps to no configured runtime), in which case no per-runtime
+ * cap applies. `decision` is the routing decision to record and dispatch, with
+ * `selected` overridden to the chosen runtime's model when a preference list
+ * redirected the task.
+ */
+export type RuntimeDispatchSelection = {
+    readonly runtimeId: LocalRuntimeId | undefined;
+    readonly decision: RoutingDecision;
+};
+/**
+ * Maps a selected local model back to the configured runtime that serves it, by
+ * matching the model against each runtime's `defaultModel`. Returns `undefined`
+ * when no configured runtime serves the model (e.g. a bare `router.localDefault`
+ * with no matching runtime entry, or a frontier model). Pure.
+ */
+export declare function runtimeIdOfModel(model: ModelSelection, config: OpenTeamConfig): LocalRuntimeId | undefined;
+/**
+ * Resolves the local runtime a role's task dispatches to, honouring an ordered
+ * preference list when the role declares one (#144). Pure and deterministic: no
+ * I/O, clock, or randomness — reachability arrives as data in `reachable`.
+ *
+ * Rules:
+ * - A non-local route (frontier/blocked) is returned unchanged with no runtime
+ *   pin — per-runtime caps apply only to local dispatch.
+ * - When the role lists runtimes and a reachable set is provided, the FIRST
+ *   listed runtime that is both reachable AND configured wins; the decision's
+ *   model is overridden to that runtime's `defaultModel` so the task actually
+ *   runs on the chosen runtime (failover + pinning). An unreachable runtime is
+ *   skipped; capacity is NOT a selection input, so a saturated-but-reachable
+ *   runtime is still chosen and its excess work queues rather than spilling.
+ * - Without a usable list (no list, no reachable set, or none of the listed
+ *   runtimes reachable/configured) the router's own local pick stands and its
+ *   runtime is resolved via `runtimeIdOfModel` so capacity is still enforced.
+ */
+export declare function selectDispatchRuntime(role: AgentRoleProfile, decision: RoutingDecision, reachable: ReadonlySet<LocalRuntimeId> | undefined, config: OpenTeamConfig): RuntimeDispatchSelection;
+//# sourceMappingURL=runtimeSelection.d.ts.map

package/dist/orchestrator/runtimeSelection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtimeSelection.d.ts","sourceRoot":"","sources":["../../src/orchestrator/runtimeSelection.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAgB,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACrE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAErD,OAAO,KAAK,EAAE,cAAc,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AACvE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAEhD;;;;;;;;;;GAUG;AACH,MAAM,MAAM,wBAAwB,GAAG;IACrC,QAAQ,CAAC,SAAS,EAAE,cAAc,GAAG,SAAS,CAAC;IAC/C,QAAQ,CAAC,QAAQ,EAAE,eAAe,CAAC;CACpC,CAAC;AASF;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,cAAc,EACrB,MAAM,EAAE,cAAc,GACrB,cAAc,GAAG,SAAS,CAI5B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CACnC,IAAI,EAAE,gBAAgB,EACtB,QAAQ,EAAE,eAAe,EACzB,SAAS,EAAE,WAAW,CAAC,cAAc,CAAC,GAAG,SAAS,EAClD,MAAM,EAAE,cAAc,GACrB,wBAAwB,CA2B1B"}

package/dist/orchestrator/sddCompiler.d.ts

@@ -1,72 +1,72 @@
 import { type GraphSpecV1 } from "../graph/schema";
 import type { TaskSignals } from "../router/types";
-/** Rol reviewer por defecto de la compilación SDD → grafo. */
+/** Default reviewer role for SDD → graph compilation. */
 export declare const DEFAULT_REVIEWER_ROLE_ID = "reviewer";
 /**
- * Descriptor de entrada del compilador SDD → grafo.
+ * Input descriptor for the SDD → graph compiler.
  *
- * Es el contrato que `compileSddTask` y el ingress activo (`graphIngress.ts`)
- * consumen: identifica la tarea, sus roles y su brief accionable, más las
- * señales de routing. El brief nunca se persiste en crudo; el compilador lo
- * ancla por digest (`assertReferenceOnly` rechaza cualquier campo crudo).
+ * It is the contract consumed by `compileSddTask` and the active ingress
+ * (`graphIngress.ts`): it identifies the task, its roles, and its actionable
+ * brief, plus the routing signals. The brief is never persisted raw; the
+ * compiler anchors it by digest (`assertReferenceOnly` rejects any raw field).
  */
 export type SddTask = {
-    /** Id estable y sin `:` (kebab-case) usado para anclas y nodos. */
+    /** Stable id with no `:` (kebab-case) used for anchors and nodes. */
     id: string;
-    /** Rol que implementa (y arregla) la tarea. */
+    /** Role that implements (and fixes) the task. */
     implementerRoleID: string;
-    /** Título humano corto. */
+    /** Short human-readable title. */
     title: string;
-    /** Brief accionable de la tarea (cuerpo del prompt del implementer). */
+    /** Actionable task brief (body of the implementer's prompt). */
     brief: string;
-    /** Señales de routing para la tarea. */
+    /** Routing signals for the task. */
     task: TaskSignals;
-    /** Rol reviewer específico (sobreescribe el reviewer por defecto). */
+    /** Specific reviewer role (overrides the default reviewer). */
     reviewerRoleID?: string;
 };
 /**
- * Compilador **puro** de una tarea SDD legacy a un `GraphSpecV1` estático
+ * **Pure** compiler from a legacy SDD task to a static `GraphSpecV1`
  * (GE-041).
  *
- * La cadena implement → review → revise → re-review se expande a un DAG
- * acíclico versionado: un nodo `implementer` inicial, su `reviewer`, y por cada
- * ronda de revisión un nuevo `implementer` (revise) con su `reviewer`
- * (re-review). El spec resultante:
+ * The implement → review → revise → re-review chain expands to a versioned
+ * acyclic DAG: an initial `implementer` node, its `reviewer`, and for each
+ * review round a new `implementer` (revise) with its `reviewer` (re-review).
+ * The resulting spec:
  *
- * - es **reference-only**: los nodos solo llevan ids, roles y un `anchor`
- *   (taskID + digest), nunca el brief crudo;
- * - es **determinista**: la misma tarea produce el mismo spec y el mismo
+ * - is **reference-only**: nodes carry only ids, roles, and an `anchor`
+ *   (taskID + digest), never the raw brief;
+ * - is **deterministic**: the same task produces the same spec and the same
  *   digest (`graphSpecDigest`);
- * - **falla antes de dispatch** ante un rol inválido, un autor que también
- *   revisa, o un id de tarea que no es un `NodeID` válido.
+ * - **fails before dispatch** on an invalid role, an author who also reviews,
+ *   or a task id that is not a valid `NodeID`.
  *
- * Sin I/O, reloj ni random: solo cómputo de digest y validación estructural.
+ * Without I/O, clock, or random: only digest computation and structural validation.
  */
-/** Código de fallo de compilación (falla antes de cualquier dispatch). */
+/** Compilation failure code (fails before any dispatch). */
 export type SddCompileErrorCode = "invalid-role" | "author-is-reviewer" | "invalid-spec";
-/** Error tipado de una compilación rechazada. */
+/** Typed error for a rejected compilation. */
 export declare class SddCompileError extends Error {
     readonly code: SddCompileErrorCode;
     readonly detail: string;
     constructor(code: SddCompileErrorCode, detail: string);
 }
-/** Opciones de compilación. */
+/** Compilation options. */
 export type SddCompileOptions = {
-    /** Rol del reviewer (def: el de la tarea o `reviewer`). */
+    /** Reviewer role (default: the task's or `reviewer`). */
     reviewerRoleID?: string;
-    /** Rondas de revisión revise/re-review a expandir (def: 1). */
+    /** revise/re-review review rounds to expand (default: 1). */
     revisionRounds?: number;
 };
 /**
- * Digest canónico del spec. Reexportado desde `graph/ids` para no romper a los
- * consumidores del compilador; la implementación vive en la capa de grafo
- * porque el espejo shadow la necesita sin alcanzar este módulo.
+ * Canonical digest of the spec. Re-exported from `graph/ids` to avoid breaking
+ * compiler consumers; the implementation lives in the graph layer because the
+ * shadow mirror needs it without reaching this module.
  */
 export { graphSpecDigest } from "../graph/ids";
 /**
- * Compila una tarea SDD legacy a un `GraphSpecV1` validado. Lanza
- * `SddCompileError` ante rol/autor/spec inválidos, siempre **antes** de
- * cualquier dispatch.
+ * Compiles a legacy SDD task to a validated `GraphSpecV1`. Throws
+ * `SddCompileError` for invalid role/author/spec, always **before** any
+ * dispatch.
  */
 export declare function compileSddTask(task: SddTask, options?: SddCompileOptions): GraphSpecV1;
 //# sourceMappingURL=sddCompiler.d.ts.map

package/dist/orchestrator/sddCompiler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sddCompiler.d.ts","sourceRoot":"","sources":["../../src/orchestrator/sddCompiler.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,WAAW,EAEjB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,8DAA8D;AAC9D,eAAO,MAAM,wBAAwB,aAAa,CAAC;AAEnD;;;;;;;GAOG;AACH,MAAM,MAAM,OAAO,GAAG;IACpB,mEAAmE;IACnE,EAAE,EAAE,MAAM,CAAC;IACX,+CAA+C;IAC/C,iBAAiB,EAAE,MAAM,CAAC;IAC1B,2BAA2B;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,wEAAwE;IACxE,KAAK,EAAE,MAAM,CAAC;IACd,wCAAwC;IACxC,IAAI,EAAE,WAAW,CAAC;IAClB,sEAAsE;IACtE,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AAEH,0EAA0E;AAC1E,MAAM,MAAM,mBAAmB,GAC3B,cAAc,GACd,oBAAoB,GACpB,cAAc,CAAC;AAEnB,iDAAiD;AACjD,qBAAa,eAAgB,SAAQ,KAAK;IACxC,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB,YAAY,IAAI,EAAE,mBAAmB,EAAE,MAAM,EAAE,MAAM,EAKpD;CACF;AAED,+BAA+B;AAC/B,MAAM,MAAM,iBAAiB,GAAG;IAC9B,2DAA2D;IAC3D,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,+DAA+D;IAC/D,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAwBF;;;;GAIG;AACH,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAE/C;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,OAAO,EACb,OAAO,GAAE,iBAAsB,GAC9B,WAAW,CA0Db"}
+{"version":3,"file":"sddCompiler.d.ts","sourceRoot":"","sources":["../../src/orchestrator/sddCompiler.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,WAAW,EAEjB,MAAM,iBAAiB,CAAC;AAEzB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEnD,yDAAyD;AACzD,eAAO,MAAM,wBAAwB,aAAa,CAAC;AAEnD;;;;;;;GAOG;AACH,MAAM,MAAM,OAAO,GAAG;IACpB,qEAAqE;IACrE,EAAE,EAAE,MAAM,CAAC;IACX,iDAAiD;IACjD,iBAAiB,EAAE,MAAM,CAAC;IAC1B,kCAAkC;IAClC,KAAK,EAAE,MAAM,CAAC;IACd,gEAAgE;IAChE,KAAK,EAAE,MAAM,CAAC;IACd,oCAAoC;IACpC,IAAI,EAAE,WAAW,CAAC;IAClB,+DAA+D;IAC/D,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF;;;;;;;;;;;;;;;;;GAiBG;AAEH,4DAA4D;AAC5D,MAAM,MAAM,mBAAmB,GAC3B,cAAc,GACd,oBAAoB,GACpB,cAAc,CAAC;AAEnB,8CAA8C;AAC9C,qBAAa,eAAgB,SAAQ,KAAK;IACxC,QAAQ,CAAC,IAAI,EAAE,mBAAmB,CAAC;IACnC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB,YAAY,IAAI,EAAE,mBAAmB,EAAE,MAAM,EAAE,MAAM,EAKpD;CACF;AAED,2BAA2B;AAC3B,MAAM,MAAM,iBAAiB,GAAG;IAC9B,yDAAyD;IACzD,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,6DAA6D;IAC7D,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB,CAAC;AAwBF;;;;GAIG;AACH,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAE/C;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,OAAO,EACb,OAAO,GAAE,iBAAsB,GAC9B,WAAW,CA0Db"}

package/dist/orchestrator/sessionReconciler.d.ts

@@ -1,35 +1,37 @@
 import type { NodeStatus } from "../graph/types";
 /**
- * Reconciliador de ventanas de crash de create/prompt (GE-032).
+ * Reconciler for create/prompt crash windows (GE-032).
  *
- * Tras un fallo a mitad de crear la sub-sesión hija o despachar el prompt, el
- * runtime no sabe si el efecto llegó a empezar. Este módulo clasifica la
- * ventana usando la **sesión hija correlacionada** de opencode y decide sin
- * reintentar a ciegas:
+ * After a failure halfway through creating the child sub-session or dispatching
+ * the prompt, the runtime does not know whether the effect started. This module
+ * classifies the window using the **correlated child session** from opencode and
+ * decides without retrying blindly:
  *
- * - `not-started`: no hay hija correlacionada; el efecto puede despacharse.
- * - `active`: existe una única hija correlacionada aún en curso; se **adopta**.
- * - `completed`: existe una única hija correlacionada terminada; se **adopta**.
- * - `unknown`: la evidencia es ambigua (varias hijas correlacionadas); se
- *   **bloquea** el reintento ciego y se exige reconciliación segura.
+ * - `not-started`: there is no correlated child; the effect can be dispatched.
+ * - `active`: exactly one correlated child exists and is still in progress; it
+ *   is **adopted**.
+ * - `completed`: exactly one correlated child exists and has finished; it is
+ *   **adopted**.
+ * - `unknown`: the evidence is ambiguous (multiple correlated children); the
+ *   blind retry is **blocked** and safe reconciliation is required.
  *
- * Un nodo con recibo ya escrito (terminal) hace que la reconciliación sea un
- * **no-op idempotente**. Puro y determinista: sin I/O, reloj ni random; el
- * runtime le pasa la evidencia ya observada a través de puertos inyectados.
+ * A node with a receipt already written (terminal) makes reconciliation an
+ * **idempotent no-op**. Pure and deterministic: no I/O, clock, or random; the
+ * runtime passes it the already observed evidence through injected ports.
  */
-/** Clasificación de la ventana de crash de un efecto. */
+/** Classification of an effect's crash window. */
 export type CrashWindowClass = "not-started" | "active" | "completed" | "unknown";
-/** Decisión de reconciliación derivada de la ventana. */
+/** Reconciliation decision derived from the window. */
 export type ReconcileDecision = "dispatch" | "adopt" | "block" | "noop";
-/** Estado observado de una sesión hija de opencode. */
+/** Observed state of an opencode child session. */
 export type ObservedChildState = "active" | "completed";
-/** Sesión hija observada con su título de correlación y estado. */
+/** Observed child session with its correlation title and state. */
 export type ObservedChild = {
     readonly sessionID: string;
     readonly title: string;
     readonly state: ObservedChildState;
 };
-/** Evidencia correlacionada sobre la hija de un intento concreto. */
+/** Correlated evidence about the child of a concrete attempt. */
 export type ChildObservation = {
     readonly kind: "none";
 } | {
@@ -42,33 +44,33 @@ export type ChildObservation = {
     readonly kind: "ambiguous";
     readonly detail: string;
 };
-/** Entrada de la reconciliación de un nodo. */
+/** Input for reconciling a node. */
 export type ReconcileInput = {
     readonly nodeStatus: NodeStatus;
     readonly observation: ChildObservation;
 };
-/** Resultado de la reconciliación: ventana, decisión y hija adoptada si aplica. */
+/** Reconciliation result: window, decision, and adopted child if applicable. */
 export type ReconcileResult = {
     readonly window: CrashWindowClass;
     readonly decision: ReconcileDecision;
     readonly sessionID?: string;
 };
 /**
- * Título de correlación determinista de la hija del intento `(runID, op,
- * attempt)`. El runtime lo fija como título de la sub-sesión al crearla, de
- * modo que un reinicio pueda reencontrar exactamente la misma hija.
+ * Deterministic correlation title of the child for attempt `(runID, op,
+ * attempt)`. The runtime sets it as the sub-session title when creating it, so
+ * that a restart can find exactly the same child again.
  */
 export declare function correlationTitle(runID: string, operationID: string, attemptID: string): string;
 /**
- * Reduce las hijas observadas a la evidencia correlacionada del intento. Cero
- * coincidencias es `none`; exactamente una determina `active`/`completed`;
- * más de una es `ambiguous` (no se puede adoptar una sola con seguridad).
+ * Reduces the observed children to the correlated evidence for the attempt.
+ * Zero matches is `none`; exactly one determines `active`/`completed`; more
+ * than one is `ambiguous` (a single one cannot be adopted safely).
  */
 export declare function observeChild(expectedTitle: string, children: readonly ObservedChild[]): ChildObservation;
 /**
- * Clasifica la ventana de crash de un nodo y decide la acción segura. Un nodo
- * terminal (recibo ya escrito) es un no-op idempotente; un nodo `pending` no ha
- * empezado; un nodo `running` se clasifica por la evidencia correlacionada.
+ * Classifies a node's crash window and decides the safe action. A terminal node
+ * (receipt already written) is an idempotent no-op; a `pending` node has not
+ * started; a `running` node is classified by the correlated evidence.
  */
 export declare function reconcileSession(input: ReconcileInput): ReconcileResult;
 //# sourceMappingURL=sessionReconciler.d.ts.map

package/dist/orchestrator/sessionReconciler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sessionReconciler.d.ts","sourceRoot":"","sources":["../../src/orchestrator/sessionReconciler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD;;;;;;;;;;;;;;;;;GAiBG;AAEH,yDAAyD;AACzD,MAAM,MAAM,gBAAgB,GACxB,aAAa,GACb,QAAQ,GACR,WAAW,GACX,SAAS,CAAC;AAEd,yDAAyD;AACzD,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,CAAC;AAExE,uDAAuD;AACvD,MAAM,MAAM,kBAAkB,GAAG,QAAQ,GAAG,WAAW,CAAC;AAExD,mEAAmE;AACnE,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,kBAAkB,CAAC;CACpC,CAAC;AAEF,qEAAqE;AACrE,MAAM,MAAM,gBAAgB,GACxB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACzB;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACvD;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAC1D;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE5D,+CAA+C;AAC/C,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,QAAQ,CAAC,WAAW,EAAE,gBAAgB,CAAC;CACxC,CAAC;AAEF,mFAAmF;AACnF,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAClC,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAC;IACrC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AAIF;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,GAChB,MAAM,CAER;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,SAAS,aAAa,EAAE,GACjC,gBAAgB,CAelB;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,cAAc,GAAG,eAAe,CAiCvE"}
+{"version":3,"file":"sessionReconciler.d.ts","sourceRoot":"","sources":["../../src/orchestrator/sessionReconciler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,kDAAkD;AAClD,MAAM,MAAM,gBAAgB,GACxB,aAAa,GACb,QAAQ,GACR,WAAW,GACX,SAAS,CAAC;AAEd,uDAAuD;AACvD,MAAM,MAAM,iBAAiB,GAAG,UAAU,GAAG,OAAO,GAAG,OAAO,GAAG,MAAM,CAAC;AAExE,mDAAmD;AACnD,MAAM,MAAM,kBAAkB,GAAG,QAAQ,GAAG,WAAW,CAAC;AAExD,mEAAmE;AACnE,MAAM,MAAM,aAAa,GAAG;IAC1B,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,kBAAkB,CAAC;CACpC,CAAC;AAEF,iEAAiE;AACjE,MAAM,MAAM,gBAAgB,GACxB;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GACzB;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GACvD;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,GAC1D;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAE5D,oCAAoC;AACpC,MAAM,MAAM,cAAc,GAAG;IAC3B,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;IAChC,QAAQ,CAAC,WAAW,EAAE,gBAAgB,CAAC;CACxC,CAAC;AAEF,gFAAgF;AAChF,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAClC,QAAQ,CAAC,QAAQ,EAAE,iBAAiB,CAAC;IACrC,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AAIF;;;;GAIG;AACH,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,MAAM,EACb,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,GAChB,MAAM,CAER;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,SAAS,aAAa,EAAE,GACjC,gBAAgB,CAelB;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,cAAc,GAAG,eAAe,CAiCvE"}