crewly 1.6.3 → 1.6.5

package/dist/backend/backend/src/services/orchestrator/onboarding-mode-loader.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Onboarding mode prompt + skill allowlist loader (Onboarding v3 — B3).
+ *
+ * Resolves the onboarding-mode system prompt and skill allowlist that the
+ * orc loads when cold-start detection (B1) fires. The real content is
+ * authored by Max on `feat/onboarding-v3-orc-prompt-skills`:
+ *
+ * - `backend/src/services/orchestrator/prompts/onboarding-mode.prompt.ts`
+ *   exports `ONBOARDING_MODE_SYSTEM_PROMPT: string`
+ * - `backend/src/services/orchestrator/onboarding-mode.skill-allowlist.ts`
+ *   exports `ONBOARDING_SKILL_ALLOWLIST: readonly string[]` plus
+ *   `isOnboardingSkillAllowed(name)` / `filterAllowedOnboardingSkills(names)`.
+ *
+ * Until Max's branch merges, those modules don't exist on this branch.
+ * This loader uses a dynamic-import-with-fallback so the build is atomic
+ * and the orc still has *something* to load on a cold start. After Max's
+ * branch merges, the real exports take over with no rebuild needed.
+ *
+ * Decoupled module path (string variable, not literal) is intentional —
+ * keeps TypeScript's module resolver from emitting a compile error when
+ * the target file is absent.
+ *
+ * @module services/orchestrator/onboarding-mode-loader
+ */
+/**
+ * Default onboarding-mode system prompt — used when Max's prompt module
+ * is not yet available. Mon EOD demo can run on this; Max replaces it
+ * with the production prompt at the import path below when his branch
+ * lands.
+ */
+export declare const ONBOARDING_FALLBACK_PROMPT: string;
+/**
+ * Default skill allowlist — used when Max's allowlist module is not yet
+ * available. Matches the brief: recall / remember / record-learning +
+ * the 2 onboarding-specific skills (`recommend-team`, `materialize-team`).
+ * `delegate-task`, `start-agent`, `stop-agent` are intentionally absent.
+ */
+export declare const ONBOARDING_FALLBACK_ALLOWLIST: readonly string[];
+/**
+ * Resolve the onboarding-mode system prompt.
+ *
+ * On first call, attempts to load the production prompt module; on
+ * subsequent calls returns the cached value. Failure (module missing,
+ * export missing, wrong type) returns the fallback.
+ *
+ * @returns Onboarding-mode system prompt string
+ */
+export declare function loadOnboardingPrompt(): Promise<string>;
+/**
+ * Resolve the onboarding-mode skill allowlist.
+ *
+ * Caching, fallback semantics, and validation mirror `loadOnboardingPrompt`.
+ *
+ * @returns Allowed skill names (kebab-case match against `mcp-tool-definitions`)
+ */
+export declare function loadOnboardingSkillAllowlist(): Promise<readonly string[]>;
+/**
+ * Reset the cached prompt + allowlist. Test-only helper.
+ *
+ * Production callers should leave the cache alone — the modules are
+ * effectively immutable for the lifetime of the process.
+ *
+ * @internal
+ */
+export declare function _resetOnboardingModeLoaderForTesting(): void;
+//# sourceMappingURL=onboarding-mode-loader.d.ts.map

package/dist/backend/backend/src/services/orchestrator/onboarding-mode-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onboarding-mode-loader.d.ts","sourceRoot":"","sources":["../../../../../../backend/src/services/orchestrator/onboarding-mode-loader.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAIH;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,QAGe,CAAC;AAEvD;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B,EAAE,SAAS,MAAM,EAMzD,CAAC;AAwCH;;;;;;;;GAQG;AACH,wBAAsB,oBAAoB,IAAI,OAAO,CAAC,MAAM,CAAC,CAkB5D;AAED;;;;;;GAMG;AACH,wBAAsB,4BAA4B,IAAI,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC,CAkB/E;AAED;;;;;;;GAOG;AACH,wBAAgB,oCAAoC,IAAI,IAAI,CAG3D"}

package/dist/backend/backend/src/services/orchestrator/onboarding-mode-loader.js

@@ -0,0 +1,145 @@
+/**
+ * Onboarding mode prompt + skill allowlist loader (Onboarding v3 — B3).
+ *
+ * Resolves the onboarding-mode system prompt and skill allowlist that the
+ * orc loads when cold-start detection (B1) fires. The real content is
+ * authored by Max on `feat/onboarding-v3-orc-prompt-skills`:
+ *
+ * - `backend/src/services/orchestrator/prompts/onboarding-mode.prompt.ts`
+ *   exports `ONBOARDING_MODE_SYSTEM_PROMPT: string`
+ * - `backend/src/services/orchestrator/onboarding-mode.skill-allowlist.ts`
+ *   exports `ONBOARDING_SKILL_ALLOWLIST: readonly string[]` plus
+ *   `isOnboardingSkillAllowed(name)` / `filterAllowedOnboardingSkills(names)`.
+ *
+ * Until Max's branch merges, those modules don't exist on this branch.
+ * This loader uses a dynamic-import-with-fallback so the build is atomic
+ * and the orc still has *something* to load on a cold start. After Max's
+ * branch merges, the real exports take over with no rebuild needed.
+ *
+ * Decoupled module path (string variable, not literal) is intentional —
+ * keeps TypeScript's module resolver from emitting a compile error when
+ * the target file is absent.
+ *
+ * @module services/orchestrator/onboarding-mode-loader
+ */
+import { LoggerService } from '../core/logger.service.js';
+/**
+ * Default onboarding-mode system prompt — used when Max's prompt module
+ * is not yet available. Mon EOD demo can run on this; Max replaces it
+ * with the production prompt at the import path below when his branch
+ * lands.
+ */
+export const ONBOARDING_FALLBACK_PROMPT = 'You are Crewly, an AI team orchestrator. The user is onboarding for ' +
+    'the first time. Greet them warmly, then ask about their business so ' +
+    'you can recommend an initial AI team and workflow.';
+/**
+ * Default skill allowlist — used when Max's allowlist module is not yet
+ * available. Matches the brief: recall / remember / record-learning +
+ * the 2 onboarding-specific skills (`recommend-team`, `materialize-team`).
+ * `delegate-task`, `start-agent`, `stop-agent` are intentionally absent.
+ */
+export const ONBOARDING_FALLBACK_ALLOWLIST = Object.freeze([
+    'recall',
+    'remember',
+    'record-learning',
+    'recommend-team',
+    'materialize-team',
+]);
+/**
+ * Module specifiers that reach Max's exports after his branch merges.
+ *
+ * Stored in `let`-typed `string` variables (not literal strings or template
+ * literals) so TypeScript treats the dynamic `import(spec)` call as
+ * `Promise<any>` rather than attempting to resolve the path at compile
+ * time. This keeps the build atomic even when the target files are absent.
+ */
+const PROMPT_MODULE_PATH = './prompts/onboarding-mode.prompt.js';
+const ALLOWLIST_MODULE_PATH = './onboarding-mode.skill-allowlist.js';
+const PROMPT_EXPORT_NAME = 'ONBOARDING_MODE_SYSTEM_PROMPT';
+const ALLOWLIST_EXPORT_NAME = 'ONBOARDING_SKILL_ALLOWLIST';
+let cachedPrompt = null;
+let cachedAllowlist = null;
+const getLogger = () => LoggerService.getInstance().createComponentLogger('OnboardingModeLoader');
+/**
+ * Dynamic import that swallows ENOENT-style failures.
+ *
+ * Cast to `unknown` so callers narrow with their own type guard — keeps
+ * the loader safe even if Max changes the export shape unexpectedly.
+ */
+async function tryImport(specifier) {
+    try {
+        return (await import(specifier));
+    }
+    catch (err) {
+        getLogger().debug('Dynamic import failed; using fallback', {
+            specifier,
+            error: err instanceof Error ? err.message : String(err),
+        });
+        return null;
+    }
+}
+/**
+ * Resolve the onboarding-mode system prompt.
+ *
+ * On first call, attempts to load the production prompt module; on
+ * subsequent calls returns the cached value. Failure (module missing,
+ * export missing, wrong type) returns the fallback.
+ *
+ * @returns Onboarding-mode system prompt string
+ */
+export async function loadOnboardingPrompt() {
+    if (cachedPrompt !== null)
+        return cachedPrompt;
+    const mod = await tryImport(PROMPT_MODULE_PATH);
+    if (mod && typeof mod === 'object' && PROMPT_EXPORT_NAME in mod) {
+        const value = mod[PROMPT_EXPORT_NAME];
+        if (typeof value === 'string' && value.length > 0) {
+            getLogger().info('Loaded production onboarding prompt', {
+                promptLength: value.length,
+            });
+            cachedPrompt = value;
+            return cachedPrompt;
+        }
+    }
+    getLogger().warn('Onboarding prompt module unavailable; using fallback stub');
+    cachedPrompt = ONBOARDING_FALLBACK_PROMPT;
+    return cachedPrompt;
+}
+/**
+ * Resolve the onboarding-mode skill allowlist.
+ *
+ * Caching, fallback semantics, and validation mirror `loadOnboardingPrompt`.
+ *
+ * @returns Allowed skill names (kebab-case match against `mcp-tool-definitions`)
+ */
+export async function loadOnboardingSkillAllowlist() {
+    if (cachedAllowlist !== null)
+        return cachedAllowlist;
+    const mod = await tryImport(ALLOWLIST_MODULE_PATH);
+    if (mod && typeof mod === 'object' && ALLOWLIST_EXPORT_NAME in mod) {
+        const value = mod[ALLOWLIST_EXPORT_NAME];
+        if (Array.isArray(value) && value.every((v) => typeof v === 'string')) {
+            getLogger().info('Loaded production onboarding skill allowlist', {
+                count: value.length,
+            });
+            cachedAllowlist = Object.freeze([...value]);
+            return cachedAllowlist;
+        }
+    }
+    getLogger().warn('Onboarding skill allowlist module unavailable; using fallback stub');
+    cachedAllowlist = ONBOARDING_FALLBACK_ALLOWLIST;
+    return cachedAllowlist;
+}
+/**
+ * Reset the cached prompt + allowlist. Test-only helper.
+ *
+ * Production callers should leave the cache alone — the modules are
+ * effectively immutable for the lifetime of the process.
+ *
+ * @internal
+ */
+export function _resetOnboardingModeLoaderForTesting() {
+    cachedPrompt = null;
+    cachedAllowlist = null;
+}
+//# sourceMappingURL=onboarding-mode-loader.js.map

package/dist/backend/backend/src/services/orchestrator/onboarding-mode-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"onboarding-mode-loader.js","sourceRoot":"","sources":["../../../../../../backend/src/services/orchestrator/onboarding-mode-loader.ts"],"names":[],"mappings":"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"}

package/dist/backend/backend/src/services/orchestrator/onboarding-mode.skill-allowlist.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Onboarding-Mode Skill Allowlist
+ *
+ * When the orchestrator is in `'onboarding'` mode, only the skills in
+ * {@link ONBOARDING_SKILL_ALLOWLIST} are callable. The runtime gate that
+ * enforces this lives in Leo's mcp-tool-definitions / skill-registry
+ * filter; this file is the single source of truth for the allow set.
+ *
+ * Matching is **by skill name** (e.g. `"recall"`), not by file path. The
+ * runtime walks the registry, takes each tool's logical name, and keeps
+ * the entry only if the name appears here.
+ *
+ * Why an allowlist (not a denylist):
+ *   - Onboarding is a tightly-scoped 5-min flow.
+ *   - Spawning workers (delegate-task / start-agent / stop-agent) before
+ *     the team is materialized would create orphan agents.
+ *   - Future skills get added to Crewly without thinking about
+ *     onboarding; default-deny keeps onboarding hermetic.
+ *
+ * @module services/orchestrator/onboarding-mode.skill-allowlist
+ */
+/**
+ * The exhaustive list of skills callable while orc is in onboarding mode.
+ *
+ * Keep this list in sync with the SKILL ACCESS section of
+ * {@link ./prompts/onboarding-mode.prompt.ts}; the prompt test asserts
+ * each name appears in the prompt, so divergence is caught at test time.
+ *
+ * Imported by:
+ *   - The orchestrator runtime / skill-registry filter (Leo).
+ *   - The allowlist test in this directory.
+ */
+export declare const ONBOARDING_SKILL_ALLOWLIST: readonly string[];
+/**
+ * Type-narrowed alias of an allowlisted skill name. Useful for callers
+ * that want compile-time guarantees (e.g. tests, registry filters).
+ */
+export type OnboardingAllowedSkill = (typeof ONBOARDING_SKILL_ALLOWLIST)[number];
+/**
+ * Predicate: is the named skill callable in onboarding mode?
+ *
+ * @param skillName - Skill logical name (e.g. `"delegate-task"`).
+ * @returns `true` iff the skill is on the allowlist.
+ *
+ * @example
+ * ```ts
+ * if (isOnboardingSkillAllowed(tool.name)) registry.register(tool);
+ * ```
+ */
+export declare function isOnboardingSkillAllowed(skillName: string): boolean;
+/**
+ * Filter helper: given a list of skill names, return only those allowed
+ * in onboarding mode, preserving the input order.
+ *
+ * @param skillNames - Candidate skill names.
+ * @returns Subset of skillNames that are on the allowlist.
+ */
+export declare function filterAllowedOnboardingSkills(skillNames: readonly string[]): string[];
+//# sourceMappingURL=onboarding-mode.skill-allowlist.d.ts.map

package/dist/backend/backend/src/services/orchestrator/onboarding-mode.skill-allowlist.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"onboarding-mode.skill-allowlist.d.ts","sourceRoot":"","sources":["../../../../../../backend/src/services/orchestrator/onboarding-mode.skill-allowlist.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,0BAA0B,EAAE,SAAS,MAAM,EAYtD,CAAC;AAEH;;;GAGG;AACH,MAAM,MAAM,sBAAsB,GAAG,CAAC,OAAO,0BAA0B,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjF;;;;;;;;;;GAUG;AACH,wBAAgB,wBAAwB,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAEnE;AAED;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAC3C,UAAU,EAAE,SAAS,MAAM,EAAE,GAC5B,MAAM,EAAE,CAEV"}

package/dist/backend/backend/src/services/orchestrator/onboarding-mode.skill-allowlist.js

@@ -0,0 +1,68 @@
+/**
+ * Onboarding-Mode Skill Allowlist
+ *
+ * When the orchestrator is in `'onboarding'` mode, only the skills in
+ * {@link ONBOARDING_SKILL_ALLOWLIST} are callable. The runtime gate that
+ * enforces this lives in Leo's mcp-tool-definitions / skill-registry
+ * filter; this file is the single source of truth for the allow set.
+ *
+ * Matching is **by skill name** (e.g. `"recall"`), not by file path. The
+ * runtime walks the registry, takes each tool's logical name, and keeps
+ * the entry only if the name appears here.
+ *
+ * Why an allowlist (not a denylist):
+ *   - Onboarding is a tightly-scoped 5-min flow.
+ *   - Spawning workers (delegate-task / start-agent / stop-agent) before
+ *     the team is materialized would create orphan agents.
+ *   - Future skills get added to Crewly without thinking about
+ *     onboarding; default-deny keeps onboarding hermetic.
+ *
+ * @module services/orchestrator/onboarding-mode.skill-allowlist
+ */
+/**
+ * The exhaustive list of skills callable while orc is in onboarding mode.
+ *
+ * Keep this list in sync with the SKILL ACCESS section of
+ * {@link ./prompts/onboarding-mode.prompt.ts}; the prompt test asserts
+ * each name appears in the prompt, so divergence is caught at test time.
+ *
+ * Imported by:
+ *   - The orchestrator runtime / skill-registry filter (Leo).
+ *   - The allowlist test in this directory.
+ */
+export const ONBOARDING_SKILL_ALLOWLIST = Object.freeze([
+    // Memory — orc must be able to recall + remember during the chat.
+    'recall',
+    'remember',
+    'record-learning',
+    // Onboarding-only skills — turn discovery answers into a real team.
+    'recommend-team',
+    'materialize-team',
+    // Escalation — surface to TL on blocker.
+    'report-status',
+]);
+/**
+ * Predicate: is the named skill callable in onboarding mode?
+ *
+ * @param skillName - Skill logical name (e.g. `"delegate-task"`).
+ * @returns `true` iff the skill is on the allowlist.
+ *
+ * @example
+ * ```ts
+ * if (isOnboardingSkillAllowed(tool.name)) registry.register(tool);
+ * ```
+ */
+export function isOnboardingSkillAllowed(skillName) {
+    return ONBOARDING_SKILL_ALLOWLIST.includes(skillName);
+}
+/**
+ * Filter helper: given a list of skill names, return only those allowed
+ * in onboarding mode, preserving the input order.
+ *
+ * @param skillNames - Candidate skill names.
+ * @returns Subset of skillNames that are on the allowlist.
+ */
+export function filterAllowedOnboardingSkills(skillNames) {
+    return skillNames.filter(isOnboardingSkillAllowed);
+}
+//# sourceMappingURL=onboarding-mode.skill-allowlist.js.map

package/dist/backend/backend/src/services/orchestrator/onboarding-mode.skill-allowlist.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"onboarding-mode.skill-allowlist.js","sourceRoot":"","sources":["../../../../../../backend/src/services/orchestrator/onboarding-mode.skill-allowlist.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAsB,MAAM,CAAC,MAAM,CAAC;IACzE,kEAAkE;IAClE,QAAQ;IACR,UAAU;IACV,iBAAiB;IAEjB,oEAAoE;IACpE,gBAAgB;IAChB,kBAAkB;IAElB,yCAAyC;IACzC,eAAe;CAChB,CAAC,CAAC;AAQH;;;;;;;;;;GAUG;AACH,MAAM,UAAU,wBAAwB,CAAC,SAAiB;IACxD,OAAO,0BAA0B,CAAC,QAAQ,CAAC,SAAS,CAAC,CAAC;AACxD,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,6BAA6B,CAC3C,UAA6B;IAE7B,OAAO,UAAU,CAAC,MAAM,CAAC,wBAAwB,CAAC,CAAC;AACrD,CAAC"}

package/dist/backend/backend/src/services/orchestrator/orchestrator-setup.service.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Orchestrator Setup Service
+ *
+ * Provides a service-level entrypoint for triggering orchestrator setup,
+ * mirroring the logic behind `POST /api/orchestrator/setup`. Used by the
+ * SlackBridge auto-recovery path so it can reattempt setup without going
+ * through HTTP.
+ *
+ * Design notes:
+ * - Dependencies are injected via `setOrchestratorSetupDependencies()` from
+ *   the bootstrap layer (`backend/src/index.ts`), keeping this service
+ *   decoupled from the API context shape.
+ * - Concurrent calls are deduplicated via an in-flight promise — if a
+ *   setup is already running, the second caller awaits the same result.
+ * - Callers should impose their own timeout on the returned promise; this
+ *   service does not enforce a timeout because setup duration varies per
+ *   runtime type.
+ *
+ * @module services/orchestrator/orchestrator-setup.service
+ */
+import { type RuntimeType } from '../../constants.js';
+import type { StorageService } from '../core/storage.service.js';
+/**
+ * Minimal contract expected from the agent registration service.
+ *
+ * Defined as an inline structural type rather than imported to avoid a
+ * circular module graph (agent-registration → orchestrator → bridge →
+ * agent-registration). Matches `AgentRegistrationService.createAgentSession`.
+ */
+export interface AgentRegistrationServiceLike {
+    createAgentSession(config: {
+        sessionName: string;
+        role: string;
+        projectPath: string;
+        windowName: string;
+        runtimeType: RuntimeType;
+        forceRecreate?: boolean;
+        additionalAllowlistPaths?: string[];
+    }): Promise<{
+        success: boolean;
+        sessionName?: string;
+        message?: string;
+        error?: string;
+    }>;
+}
+/**
+ * Result of `triggerOrchestratorSetup()`.
+ */
+export interface OrchestratorSetupResult {
+    /** Whether the setup attempt succeeded (or the orchestrator was already healthy). */
+    success: boolean;
+    /** Session name if setup succeeded. */
+    sessionName?: string;
+    /** Human-readable status message. */
+    message?: string;
+    /** Error message if setup failed. */
+    error?: string;
+    /** True when setup was skipped because the orchestrator was already healthy. */
+    skipped?: boolean;
+}
+/**
+ * Injected dependencies wired by the bootstrap layer.
+ */
+interface SetupDependencies {
+    agentRegistrationService: AgentRegistrationServiceLike;
+    storageService: StorageService;
+}
+/**
+ * Wire the dependencies needed to trigger setup from any caller.
+ *
+ * Must be called once during bootstrap, after the agent registration service
+ * is created. Passing the same dependencies twice is safe (last write wins).
+ *
+ * @param deps - Required service dependencies
+ *
+ * @example
+ * ```typescript
+ * setOrchestratorSetupDependencies({
+ *   agentRegistrationService,
+ *   storageService,
+ * });
+ * ```
+ */
+export declare function setOrchestratorSetupDependencies(deps: SetupDependencies): void;
+/**
+ * Reset injected dependencies. Test-only helper.
+ *
+ * @internal
+ */
+export declare function _resetOrchestratorSetupDependenciesForTesting(): void;
+/**
+ * Trigger orchestrator setup if it is not already healthy.
+ *
+ * Steps:
+ * 1. Health-check via `getOrchestratorStatus()` — if active, return early.
+ * 2. Resolve runtime type from persisted orchestrator status (default: claude-code).
+ * 3. Call `createAgentSession()` with `forceRecreate: true`.
+ * 4. Initialize memory and start chat monitoring (best-effort).
+ *
+ * Concurrent callers receive the same in-flight promise — at most one setup
+ * runs at a time across the process.
+ *
+ * The orchestrator's conversation history (`AgentRunner.state.messages`) is
+ * left empty after this call. The registration path skips the activation
+ * kickoff message for the orchestrator session — this preserves the B1
+ * `messageCount === 0` cold-start invariant.
+ *
+ * @returns Setup result. `skipped: true` if the orchestrator was already healthy.
+ *
+ * @throws Never — errors are returned in the result object instead.
+ */
+export declare function triggerOrchestratorSetup(): Promise<OrchestratorSetupResult>;
+export {};
+//# sourceMappingURL=orchestrator-setup.service.d.ts.map

package/dist/backend/backend/src/services/orchestrator/orchestrator-setup.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"orchestrator-setup.service.d.ts","sourceRoot":"","sources":["../../../../../../backend/src/services/orchestrator/orchestrator-setup.service.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAKN,KAAK,WAAW,EAChB,MAAM,oBAAoB,CAAC;AAG5B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAKjE;;;;;;GAMG;AACH,MAAM,WAAW,4BAA4B;IAC5C,kBAAkB,CAAC,MAAM,EAAE;QAC1B,WAAW,EAAE,MAAM,CAAC;QACpB,IAAI,EAAE,MAAM,CAAC;QACb,WAAW,EAAE,MAAM,CAAC;QACpB,UAAU,EAAE,MAAM,CAAC;QACnB,WAAW,EAAE,WAAW,CAAC;QACzB,aAAa,CAAC,EAAE,OAAO,CAAC;QACxB,wBAAwB,CAAC,EAAE,MAAM,EAAE,CAAC;KACpC,GAAG,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,WAAW,CAAC,EAAE,MAAM,CAAC;QAAC,OAAO,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;CAC1F;AAED;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACvC,qFAAqF;IACrF,OAAO,EAAE,OAAO,CAAC;IACjB,uCAAuC;IACvC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,qCAAqC;IACrC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,qCAAqC;IACrC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,gFAAgF;IAChF,OAAO,CAAC,EAAE,OAAO,CAAC;CAClB;AAED;;GAEG;AACH,UAAU,iBAAiB;IAC1B,wBAAwB,EAAE,4BAA4B,CAAC;IACvD,cAAc,EAAE,cAAc,CAAC;CAC/B;AAQD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,gCAAgC,CAAC,IAAI,EAAE,iBAAiB,GAAG,IAAI,CAE9E;AAED;;;;GAIG;AACH,wBAAgB,6CAA6C,IAAI,IAAI,CAGpE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,wBAAwB,IAAI,OAAO,CAAC,uBAAuB,CAAC,CAiBjF"}

package/dist/backend/backend/src/services/orchestrator/orchestrator-setup.service.js

@@ -0,0 +1,195 @@
+/**
+ * Orchestrator Setup Service
+ *
+ * Provides a service-level entrypoint for triggering orchestrator setup,
+ * mirroring the logic behind `POST /api/orchestrator/setup`. Used by the
+ * SlackBridge auto-recovery path so it can reattempt setup without going
+ * through HTTP.
+ *
+ * Design notes:
+ * - Dependencies are injected via `setOrchestratorSetupDependencies()` from
+ *   the bootstrap layer (`backend/src/index.ts`), keeping this service
+ *   decoupled from the API context shape.
+ * - Concurrent calls are deduplicated via an in-flight promise — if a
+ *   setup is already running, the second caller awaits the same result.
+ * - Callers should impose their own timeout on the returned promise; this
+ *   service does not enforce a timeout because setup duration varies per
+ *   runtime type.
+ *
+ * @module services/orchestrator/orchestrator-setup.service
+ */
+import { ORCHESTRATOR_SESSION_NAME, ORCHESTRATOR_WINDOW_NAME, ORCHESTRATOR_ROLE, RUNTIME_TYPES, } from '../../constants.js';
+import { LoggerService } from '../core/logger.service.js';
+import { formatError } from '../../utils/format-error.js';
+import { MemoryService } from '../memory/memory.service.js';
+import { getTerminalGateway } from '../../websocket/terminal.gateway.js';
+import { getOrchestratorStatus } from './orchestrator-status.service.js';
+let dependencies = null;
+let setupInFlight = null;
+const getLogger = () => LoggerService.getInstance().createComponentLogger('OrchestratorSetup');
+/**
+ * Wire the dependencies needed to trigger setup from any caller.
+ *
+ * Must be called once during bootstrap, after the agent registration service
+ * is created. Passing the same dependencies twice is safe (last write wins).
+ *
+ * @param deps - Required service dependencies
+ *
+ * @example
+ * ```typescript
+ * setOrchestratorSetupDependencies({
+ *   agentRegistrationService,
+ *   storageService,
+ * });
+ * ```
+ */
+export function setOrchestratorSetupDependencies(deps) {
+    dependencies = deps;
+}
+/**
+ * Reset injected dependencies. Test-only helper.
+ *
+ * @internal
+ */
+export function _resetOrchestratorSetupDependenciesForTesting() {
+    dependencies = null;
+    setupInFlight = null;
+}
+/**
+ * Trigger orchestrator setup if it is not already healthy.
+ *
+ * Steps:
+ * 1. Health-check via `getOrchestratorStatus()` — if active, return early.
+ * 2. Resolve runtime type from persisted orchestrator status (default: claude-code).
+ * 3. Call `createAgentSession()` with `forceRecreate: true`.
+ * 4. Initialize memory and start chat monitoring (best-effort).
+ *
+ * Concurrent callers receive the same in-flight promise — at most one setup
+ * runs at a time across the process.
+ *
+ * The orchestrator's conversation history (`AgentRunner.state.messages`) is
+ * left empty after this call. The registration path skips the activation
+ * kickoff message for the orchestrator session — this preserves the B1
+ * `messageCount === 0` cold-start invariant.
+ *
+ * @returns Setup result. `skipped: true` if the orchestrator was already healthy.
+ *
+ * @throws Never — errors are returned in the result object instead.
+ */
+export async function triggerOrchestratorSetup() {
+    if (setupInFlight) {
+        // Concurrent call — caller waits on the existing setup.
+        return setupInFlight;
+    }
+    if (!dependencies) {
+        const error = 'Orchestrator setup dependencies not initialized';
+        getLogger().error(error);
+        return { success: false, error };
+    }
+    setupInFlight = _runSetup(dependencies).finally(() => {
+        setupInFlight = null;
+    });
+    return setupInFlight;
+}
+/**
+ * Internal setup runner. Extracted for clarity — `triggerOrchestratorSetup`
+ * just guards concurrency.
+ */
+async function _runSetup(deps) {
+    const logger = getLogger();
+    try {
+        // 1. Skip when already healthy. Avoids hammering setup when SlackBridge's
+        // auto-recovery races with another caller.
+        try {
+            const currentStatus = await getOrchestratorStatus();
+            if (currentStatus.isActive) {
+                logger.info('Orchestrator is already healthy — skipping setup', {
+                    agentStatus: currentStatus.agentStatus,
+                });
+                return {
+                    success: true,
+                    skipped: true,
+                    message: 'Orchestrator is already running (setup skipped)',
+                    sessionName: ORCHESTRATOR_SESSION_NAME,
+                };
+            }
+        }
+        catch (healthErr) {
+            logger.warn('Health check failed, proceeding with setup', {
+                error: formatError(healthErr),
+            });
+        }
+        // 2. Resolve runtime type. Falls back to claude-code if unknown.
+        let runtimeType = RUNTIME_TYPES.CLAUDE_CODE;
+        try {
+            const orchestratorStatus = await deps.storageService.getOrchestratorStatus();
+            const stored = orchestratorStatus?.runtimeType;
+            if (stored && Object.values(RUNTIME_TYPES).includes(stored)) {
+                runtimeType = stored;
+            }
+        }
+        catch (lookupErr) {
+            logger.warn('Failed to read runtime type from storage; defaulting to claude-code', {
+                error: formatError(lookupErr),
+            });
+        }
+        // 3. For Gemini CLI we'd normally collect project paths for the
+        // allowlist. The auto-recovery path is best-effort and the controller
+        // already does this on the explicit setup endpoint, so we keep it
+        // simple here. The createAgentSession contract treats the parameter
+        // as optional.
+        logger.info('Triggering createAgentSession from auto-recovery', {
+            sessionName: ORCHESTRATOR_SESSION_NAME,
+            runtimeType,
+        });
+        const result = await deps.agentRegistrationService.createAgentSession({
+            sessionName: ORCHESTRATOR_SESSION_NAME,
+            role: ORCHESTRATOR_ROLE,
+            projectPath: process.cwd(),
+            windowName: ORCHESTRATOR_WINDOW_NAME,
+            runtimeType,
+            forceRecreate: true,
+        });
+        if (!result.success) {
+            logger.error('createAgentSession returned failure', { error: result.error });
+            return {
+                success: false,
+                error: result.error || 'Failed to create orchestrator session',
+            };
+        }
+        // 4. Best-effort memory init + chat monitoring. Failures here do not
+        // block setup success — the session is created, these are auxiliary.
+        try {
+            await MemoryService.getInstance().initializeForSession(ORCHESTRATOR_SESSION_NAME, ORCHESTRATOR_ROLE, process.cwd());
+        }
+        catch (memErr) {
+            logger.warn('Memory initialization failed (non-fatal)', {
+                error: formatError(memErr),
+            });
+        }
+        try {
+            const terminalGateway = getTerminalGateway();
+            if (terminalGateway) {
+                terminalGateway.startOrchestratorChatMonitoring(ORCHESTRATOR_SESSION_NAME);
+            }
+        }
+        catch (monitorErr) {
+            logger.warn('Failed to start chat monitoring (non-fatal)', {
+                error: formatError(monitorErr),
+            });
+        }
+        return {
+            success: true,
+            sessionName: result.sessionName ?? ORCHESTRATOR_SESSION_NAME,
+            message: result.message ?? 'Orchestrator session created and registered',
+        };
+    }
+    catch (error) {
+        logger.error('Auto-recovery setup failed', { error: formatError(error) });
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Failed to setup orchestrator session',
+        };
+    }
+}
+//# sourceMappingURL=orchestrator-setup.service.js.map