dsh-plugin-local-infer 0.1.2 → 0.1.4

package/packages/core/lib/registrar.d.ts

@@ -1,9 +1,10 @@
-import type { LaunchPlan } from './adapter.ts';
+import type { BuildMode, LaunchPlan } from './adapter.ts';
 /**
  * DshModelEntry is the shape of the model row the registrar writes into the
  * dsh-llm-pi-ai provider: the provider id, the model id and display name, the
- * context window, the engine's base URL, and the env-var name the provider
- * reads its optional API key from.
+ * context window, the engine's base URL, the env-var name the provider reads
+ * its optional API key from, and the placeholder API key value the engine
+ * ships with so a model the user has not keyed still activates.
  */
 export interface DshModelEntry {
     providerId: string;
@@ -12,6 +13,7 @@ export interface DshModelEntry {
     contextWindow: number;
     baseURL: string;
     apiKeyEnv: string;
+    apiKey: string;
     input?: string[];
 }
 /**
@@ -83,24 +85,33 @@ export interface DshModelRegistrar {
 export declare function modelSlug(modelId: string): string;
 /**
  * providerIdFor derives the provider id the registrar writes for an engine
- * and model: the engine id, the build mode (local or docker), and the model
- * slug, so a profile can carry the same engine in both build modes and
- * several models per engine without a collision.
+ * and model: the engine id, the build mode (local, docker, or binary), and the
+ * model slug, so a profile can carry the same engine in several build modes
+ * and several models per engine without a collision.
  */
-export declare function providerIdFor(engineId: string, modelId: string, buildMode: 'local' | 'docker'): string;
+export declare function providerIdFor(engineId: string, modelId: string, buildMode: BuildMode): string;
 /**
  * apiKeyEnvFor derives the env-var name a local provider reads its optional
  * API key from: the engine id, uppercased and non-alphanumerics mapped to
  * underscores, plus _LOCAL_API_KEY.
  */
 export declare function apiKeyEnvFor(engineId: string): string;
+/**
+ * defaultApiKeyFor derives the placeholder API key value a local engine ships
+ * with: the engine id, uppercased and non-alphanumerics mapped to underscores,
+ * wrapped in double braces plus _LOCAL_API_KEY. The double braces mark the
+ * value as a placeholder, not a real key, so a model the user has not keyed
+ * still activates the pi-ai OpenAI route. A user-added key replaces it in a
+ * future turn.
+ */
+export declare function defaultApiKeyFor(engineId: string): string;
 /**
  * buildModelEntry turns a launch plan and a model row into the DshModelEntry
  * the registrar writes. The provider id is the engine, build mode, and model
  * slug; the display name is the engine, the build mode in parentheses, and
  * the model name (falling back to the slug when the row carries none). The
- * API-key env name derives from the engine id, and the base URL is the
- * engine's OpenAI endpoint on its port.
+ * API-key env name and the placeholder API key value derive from the engine
+ * id, and the base URL is the engine's OpenAI endpoint on its port.
  */
 export declare function buildModelEntry(plan: LaunchPlan, model: ModelRow): DshModelEntry;
 /**
@@ -118,10 +129,10 @@ export declare function upsertModelRow(rows: readonly ModelRow[], row: ModelRow)
 export declare function removeModelRow(rows: readonly ModelRow[], modelId: string): ModelRow[];
 /**
  * providerRegistrationOps computes the settings ops that upsert a provider
- * entry: the API-key env name, the openai-completions api, the base URL, and
- * the models list with the entry's row upserted. The ops write the provider
- * fields by path, so a provider the user edited by hand keeps every field
- * the registrar does not own.
+ * entry: the API-key env name, the openai-completions api, the base URL, the
+ * placeholder Authorization header, and the models list with the entry's row
+ * upserted. The ops write the provider fields by path, so a provider the user
+ * edited by hand keeps every field the registrar does not own.
  */
 export declare function providerRegistrationOps(entry: DshModelEntry, rows: readonly ModelRow[]): SettingsOp[];
 /**
@@ -154,4 +165,4 @@ export declare function modelRowsFrom(value: unknown, providerId: string): reado
  * when it names the removed pair.
  */
 export declare function agentDefaultPointsAt(value: unknown, providerId: string, modelId: string): boolean;
-//# sourceMappingURL=registrar.d.ts.map
+//# sourceMappingURL=registrar.d.ts.map

package/packages/core/lib/registrar.js

@@ -27,9 +27,9 @@ export function modelSlug(modelId) {
 }
 /**
  * providerIdFor derives the provider id the registrar writes for an engine
- * and model: the engine id, the build mode (local or docker), and the model
- * slug, so a profile can carry the same engine in both build modes and
- * several models per engine without a collision.
+ * and model: the engine id, the build mode (local, docker, or binary), and the
+ * model slug, so a profile can carry the same engine in several build modes
+ * and several models per engine without a collision.
  */
 export function providerIdFor(engineId, modelId, buildMode) {
     return `${engineId}-${buildMode}-${modelSlug(modelId)}`;
@@ -42,6 +42,17 @@ export function providerIdFor(engineId, modelId, buildMode) {
 export function apiKeyEnvFor(engineId) {
     return `${engineId.toUpperCase().replace(/[^A-Z0-9]/g, '_')}_LOCAL_API_KEY`;
 }
+/**
+ * defaultApiKeyFor derives the placeholder API key value a local engine ships
+ * with: the engine id, uppercased and non-alphanumerics mapped to underscores,
+ * wrapped in double braces plus _LOCAL_API_KEY. The double braces mark the
+ * value as a placeholder, not a real key, so a model the user has not keyed
+ * still activates the pi-ai OpenAI route. A user-added key replaces it in a
+ * future turn.
+ */
+export function defaultApiKeyFor(engineId) {
+    return `{{${engineId.toUpperCase().replace(/[^A-Z0-9]/g, '_')}}}_LOCAL_API_KEY`;
+}
 /**
  * engineDisplayName capitalizes the first letter of an engine id for the
  * display name: `ninfer` reads as `Ninfer`, `hyperqwen` as `Hyperqwen`.
@@ -54,8 +65,8 @@ function engineDisplayName(engineId) {
  * the registrar writes. The provider id is the engine, build mode, and model
  * slug; the display name is the engine, the build mode in parentheses, and
  * the model name (falling back to the slug when the row carries none). The
- * API-key env name derives from the engine id, and the base URL is the
- * engine's OpenAI endpoint on its port.
+ * API-key env name and the placeholder API key value derive from the engine
+ * id, and the base URL is the engine's OpenAI endpoint on its port.
  */
 export function buildModelEntry(plan, model) {
     const buildMode = plan.kind === 'docker' ? 'docker' : 'local';
@@ -68,6 +79,7 @@ export function buildModelEntry(plan, model) {
         contextWindow: model.contextWindow,
         baseURL: `http://127.0.0.1:${plan.port}/v1`,
         apiKeyEnv: apiKeyEnvFor(plan.engineId),
+        apiKey: defaultApiKeyFor(plan.engineId),
     };
     // exactOptionalPropertyTypes: carry the input modalities only when the row
     // names them, so a text-only registration never writes an empty list.
@@ -101,10 +113,10 @@ export function removeModelRow(rows, modelId) {
 }
 /**
  * providerRegistrationOps computes the settings ops that upsert a provider
- * entry: the API-key env name, the openai-completions api, the base URL, and
- * the models list with the entry's row upserted. The ops write the provider
- * fields by path, so a provider the user edited by hand keeps every field
- * the registrar does not own.
+ * entry: the API-key env name, the openai-completions api, the base URL, the
+ * placeholder Authorization header, and the models list with the entry's row
+ * upserted. The ops write the provider fields by path, so a provider the user
+ * edited by hand keeps every field the registrar does not own.
  */
 export function providerRegistrationOps(entry, rows) {
     const providerPath = ['providers', entry.providerId];
@@ -119,10 +131,18 @@ export function providerRegistrationOps(entry, rows) {
     if (entry.input !== undefined) {
         row.input = entry.input;
     }
+    // The pi-ai OpenAI route requires an API key or an Authorization header, so
+    // a keyless local server ships the placeholder key as a Bearer header. The
+    // profile schema has no literal apiKey field; headers carry the value.
     return [
         { op: 'set', path: [...providerPath, 'apiKeyEnv'], value: entry.apiKeyEnv },
         { op: 'set', path: [...providerPath, 'api'], value: 'openai-completions' },
         { op: 'set', path: [...providerPath, 'baseURL'], value: entry.baseURL },
+        {
+            op: 'set',
+            path: [...providerPath, 'headers', 'Authorization'],
+            value: `Bearer ${entry.apiKey}`,
+        },
         { op: 'set', path: [...providerPath, 'models'], value: upsertModelRow(rows, row) },
     ];
 }
@@ -205,4 +225,4 @@ export function agentDefaultPointsAt(value, providerId, modelId) {
     const section = value;
     return section.provider === providerId && section.model === modelId;
 }
-//# sourceMappingURL=registrar.js.map
+//# sourceMappingURL=registrar.js.map

package/packages/core/lib/reserve.d.ts

@@ -25,6 +25,13 @@ export declare function parseNvidiaSmiGpuUsage(output: string): GpuUsageProbe |
 export interface EngineLaunchSignature {
     binary: string;
     port?: number;
+    /**
+     * When false the engine binds its port from a file (Basalt's
+     * basalt_config.json server block), so the matcher never sees the number
+     * in the command line and must skip the port element. Undefined reads as
+     * true: the port must appear as a standalone number, the current rule.
+     */
+    portInArgv?: boolean;
     envKeys?: readonly string[];
 }
 /**
@@ -44,8 +51,9 @@ export interface ProcessLine {
  * signature. The binary marker must appear in the command line (the image
  * name for a docker plan, the engine binary for a local one); a declared port
  * must appear as a standalone number (the `--port N` flag or the docker
- * `-p host:port:port` mapping); a declared env key must be set when the line
- * carries env data, and is neutral when it does not.
+ * `-p host:port:port` mapping) unless `portInArgv` is false, which means the
+ * engine binds its port from a file; a declared env key must be set when the
+ * line carries env data, and is neutral when it does not.
  */
 export declare function matchLaunchSignature(line: ProcessLine, signature: EngineLaunchSignature): boolean;
 /**
@@ -86,4 +94,4 @@ export declare function resolveOsReserve(input: {
     foreignProcess?: boolean;
     gpuUsage?: GpuUsageProbe | null;
 }): ReserveResolution;
-//# sourceMappingURL=reserve.d.ts.map
+//# sourceMappingURL=reserve.d.ts.map

package/packages/core/lib/reserve.js

@@ -29,14 +29,16 @@ export function parseNvidiaSmiGpuUsage(output) {
  * signature. The binary marker must appear in the command line (the image
  * name for a docker plan, the engine binary for a local one); a declared port
  * must appear as a standalone number (the `--port N` flag or the docker
- * `-p host:port:port` mapping); a declared env key must be set when the line
- * carries env data, and is neutral when it does not.
+ * `-p host:port:port` mapping) unless `portInArgv` is false, which means the
+ * engine binds its port from a file; a declared env key must be set when the
+ * line carries env data, and is neutral when it does not.
  */
 export function matchLaunchSignature(line, signature) {
     if (!line.command.includes(signature.binary))
         return false;
-    if (signature.port !== undefined && !portAppears(line.command, signature.port))
+    if (signature.portInArgv !== false && signature.port !== undefined && !portAppears(line.command, signature.port)) {
         return false;
+    }
     if (signature.envKeys !== undefined && signature.envKeys.length > 0 && line.env !== undefined) {
         const hit = signature.envKeys.some(key => key in line.env);
         if (!hit)
@@ -90,4 +92,4 @@ export function resolveOsReserve(input) {
     }
     return { reserveMiB: DEFAULT_OS_RESERVE_MIB, source: 'default' };
 }
-//# sourceMappingURL=reserve.js.map
+//# sourceMappingURL=reserve.js.map

package/packages/core/lib/status.d.ts

@@ -10,8 +10,10 @@ export type ProviderStatus = 'running' | 'stopped' | 'unsure';
 /**
  * ProviderRef is the identity side of one saved provider config: the stable
  * id the card renders and the engine and model it serves. The model is
- * optional because a config that names no model cannot be confirmed against
- * a running engine, and reads as unsure rather than a guess. The config is
+ * optional: a config that names no model (an absent or empty value) confirms
+ * against a plugin-launched engine the detector tied to any model on its
+ * port, and reads as unsure only while no running engine carries a model tie.
+ * The config is
  * optional and lets the detector price the provider's own launch signature
  * (the engine binary the build mode runs, the port it binds) rather than the
  * adapter's default-port signature; the port is the resolved bind port the
@@ -60,9 +62,13 @@ export declare function isGpuBusy(usage?: GpuUsageProbe | null): boolean;
  * the detector's answer. The order is the plan's contract:
  * 1. A provider whose engine the process probe confirmed running is running
  *    (green) when the detector tied that engine to the provider's exact model,
- *    and unsure (yellow) when the engine serves an unidentified or a
- *    different model. A running engine using its VRAM does not read as a busy
- *    card, so the dot is green, not the unattributable yellow.
+ *    or when the provider names no model and the detector tied the engine to
+ *    any model: only this plugin's launches and re-links stamp a model tie, so
+ *    a model-tied engine on the provider's port is that provider's own engine.
+ *    A provider reads as unsure (yellow) when the engine serves an
+ *    unidentified or a different model. A running engine using its VRAM does
+ *    not read as a busy card, so the dot is green, not the unattributable
+ *    yellow.
  * 2. A provider whose engine is not running falls back to the card state: a
  *    busy card (a foreign engine holding the VRAM at 75% or more) reads as
  *    unsure, because a full card cannot be attributed to a single model, and
@@ -70,4 +76,4 @@ export declare function isGpuBusy(usage?: GpuUsageProbe | null): boolean;
  *    a saved config whose engine is down is stopped.
  */
 export declare function computeProviderStatuses(input: ProviderStatusInput): Record<string, ProviderStatus>;
-//# sourceMappingURL=status.d.ts.map
+//# sourceMappingURL=status.d.ts.map

package/packages/core/lib/status.js

@@ -11,14 +11,26 @@ export function isGpuBusy(usage) {
         return false;
     return usage.usedMiB / usage.totalMiB >= GPU_USAGE_BUSY_THRESHOLD;
 }
+/**
+ * namesNoModel reports whether one model field names no model: the absent
+ * value or the empty string. The provider side and the engine-ref side of the
+ * status tie both read it, so one rule decides both representations.
+ */
+function namesNoModel(model) {
+    return model === undefined || model === '';
+}
 /**
  * computeProviderStatuses resolves each saved provider's running-state from
  * the detector's answer. The order is the plan's contract:
  * 1. A provider whose engine the process probe confirmed running is running
  *    (green) when the detector tied that engine to the provider's exact model,
- *    and unsure (yellow) when the engine serves an unidentified or a
- *    different model. A running engine using its VRAM does not read as a busy
- *    card, so the dot is green, not the unattributable yellow.
+ *    or when the provider names no model and the detector tied the engine to
+ *    any model: only this plugin's launches and re-links stamp a model tie, so
+ *    a model-tied engine on the provider's port is that provider's own engine.
+ *    A provider reads as unsure (yellow) when the engine serves an
+ *    unidentified or a different model. A running engine using its VRAM does
+ *    not read as a busy card, so the dot is green, not the unattributable
+ *    yellow.
  * 2. A provider whose engine is not running falls back to the card state: a
  *    busy card (a foreign engine holding the VRAM at 75% or more) reads as
  *    unsure, because a full card cannot be attributed to a single model, and
@@ -37,16 +49,15 @@ export function computeProviderStatuses(input) {
         if (matches.length > 0) {
             // The engine is running. The question is which model it serves: the
             // detector's identified model, if it tied one, else unknown.
-            const identified = matches.find((ref) => ref.modelId !== undefined && ref.modelId !== '');
+            const identified = matches.find((ref) => !namesNoModel(ref.modelId));
             if (identified !== undefined &&
-                provider.model !== undefined &&
-                identified.modelId === provider.model) {
+                (namesNoModel(provider.model) || identified.modelId === provider.model)) {
                 statuses[provider.id] = 'running';
                 continue;
             }
-            // The engine is running but the model is not identified, the provider
-            // names no model, or the engine serves a different model: unsure, not
-            // a guess.
+            // The engine is running but the detector could not tie it to a model, or
+            // it serves a different model than the provider names: unsure, not a
+            // guess.
             statuses[provider.id] = 'unsure';
             continue;
         }
@@ -56,4 +67,4 @@ export function computeProviderStatuses(input) {
     }
     return statuses;
 }
-//# sourceMappingURL=status.js.map
+//# sourceMappingURL=status.js.map

package/packages/core/lib/sudo.d.ts

@@ -0,0 +1,80 @@
+/**
+ * The pure half of the sudo-prompt rule. A sudo command run by the plugin
+ * prompts on the terminal that launched the host, where the card user cannot
+ * see it, so the runners announce the prompt and cap how long it may wait.
+ * This module holds the constants and the injected-callback guard both
+ * runners drive; the child-process wiring stays in the service and the
+ * providers, so core never touches node.
+ * @module dsh-plugin-local-infer/core/sudo
+ */
+/**
+ * SUDO_CLI_NOTE is the line the Logs section, the log file, and the streamed
+ * run show when a sudo command is waiting for the user to type the password
+ * on the CLI.
+ */
+export declare const SUDO_CLI_NOTE = "Check your CLI for a sudo prompt";
+/**
+ * SUDO_PASSWORD_TIMEOUT_MS caps how long a sudo command may wait for the user
+ * to type the password on the CLI before the run kills it and fails.
+ */
+export declare const SUDO_PASSWORD_TIMEOUT_MS = 60000;
+/**
+ * SUDO_PROBE_COMMAND is the non-interactive probe that answers whether sudo
+ * already holds cached credentials (exit 0) or is about to prompt on the
+ * terminal (non-zero). The runners execute it; core only declares it.
+ */
+export declare const SUDO_PROBE_COMMAND: readonly string[];
+/**
+ * sudoFailureDetail builds the CommandOutcome.detail text for a command the
+ * sudo deadline killed, naming the CLI note and the timeout seconds so the
+ * Logs section explains what the user missed.
+ */
+export declare function sudoFailureDetail(command: string): string;
+/**
+ * SudoTimer is the injectable set/clear pair a sudo guard arms and disarms.
+ * Tests drive the clock through a fake; the default is setTimeout and
+ * clearTimeout.
+ */
+export interface SudoTimer {
+    set: (callback: () => void, ms: number) => unknown;
+    clear: (handle: unknown) => void;
+}
+/**
+ * SudoGuardOptions tunes one guarded command run. `needsSudo` is the caller's
+ * declaration (SystemDep.requiresSudo on the install path, RunOptions.needsSudo
+ * on the lifecycle path), never inferred from the command text. `probe`
+ * answers whether sudo already holds cached credentials, `notify` announces
+ * the coming prompt once, `kill` stops the command, `timeoutMs` overrides the
+ * deadline, and `timer` swaps the clock.
+ */
+export interface SudoGuardOptions {
+    needsSudo?: boolean;
+    command: string;
+    probe: () => Promise<boolean>;
+    notify: (command: string) => void;
+    kill: () => void;
+    timeoutMs?: number;
+    timer?: SudoTimer;
+}
+/**
+ * SudoGuard is the guard's answer, read by the caller around the command run.
+ * `announced` says the prompt was announced and a deadline is armed;
+ * `disarm` clears the armed deadline once the command finishes; `timedOut`
+ * reads whether the deadline already fired, so a failed run can carry
+ * sudoFailureDetail instead of a bare exit.
+ */
+export interface SudoGuard {
+    announced: boolean;
+    disarm(): void;
+    timedOut(): boolean;
+}
+/**
+ * guardSudoCommand applies the shared sudo-prompt rule for one command, so
+ * the service install runner and the providers lifecycle host drive one rule.
+ * A command the caller does not declare sudo runs through unguarded: no
+ * probe, no announcement, no timer. A declared command probes first; cached
+ * credentials (probe resolves true) run through the same way. Otherwise the
+ * guard calls notify once and arms the timeout whose fire calls kill.
+ */
+export declare function guardSudoCommand(options: SudoGuardOptions): Promise<SudoGuard>;
+//# sourceMappingURL=sudo.d.ts.map

package/packages/core/lib/sudo.js

@@ -0,0 +1,78 @@
+/**
+ * The pure half of the sudo-prompt rule. A sudo command run by the plugin
+ * prompts on the terminal that launched the host, where the card user cannot
+ * see it, so the runners announce the prompt and cap how long it may wait.
+ * This module holds the constants and the injected-callback guard both
+ * runners drive; the child-process wiring stays in the service and the
+ * providers, so core never touches node.
+ * @module dsh-plugin-local-infer/core/sudo
+ */
+/**
+ * SUDO_CLI_NOTE is the line the Logs section, the log file, and the streamed
+ * run show when a sudo command is waiting for the user to type the password
+ * on the CLI.
+ */
+export const SUDO_CLI_NOTE = 'Check your CLI for a sudo prompt';
+/**
+ * SUDO_PASSWORD_TIMEOUT_MS caps how long a sudo command may wait for the user
+ * to type the password on the CLI before the run kills it and fails.
+ */
+export const SUDO_PASSWORD_TIMEOUT_MS = 60_000;
+/**
+ * SUDO_PROBE_COMMAND is the non-interactive probe that answers whether sudo
+ * already holds cached credentials (exit 0) or is about to prompt on the
+ * terminal (non-zero). The runners execute it; core only declares it.
+ */
+export const SUDO_PROBE_COMMAND = ['sudo', '-n', 'true'];
+/**
+ * sudoFailureDetail builds the CommandOutcome.detail text for a command the
+ * sudo deadline killed, naming the CLI note and the timeout seconds so the
+ * Logs section explains what the user missed.
+ */
+export function sudoFailureDetail(command) {
+    return (`${command} was killed: no sudo password was entered within ` +
+        `${SUDO_PASSWORD_TIMEOUT_MS / 1000} seconds. ${SUDO_CLI_NOTE}`);
+}
+/** DEFAULT_SUDO_TIMER is the guard clock when the caller injects none. */
+const DEFAULT_SUDO_TIMER = {
+    set: (callback, ms) => setTimeout(callback, ms),
+    clear: (handle) => clearTimeout(handle),
+};
+/**
+ * guardSudoCommand applies the shared sudo-prompt rule for one command, so
+ * the service install runner and the providers lifecycle host drive one rule.
+ * A command the caller does not declare sudo runs through unguarded: no
+ * probe, no announcement, no timer. A declared command probes first; cached
+ * credentials (probe resolves true) run through the same way. Otherwise the
+ * guard calls notify once and arms the timeout whose fire calls kill.
+ */
+export async function guardSudoCommand(options) {
+    if (options.needsSudo !== true) {
+        return unguarded();
+    }
+    if (await options.probe()) {
+        return unguarded();
+    }
+    options.notify(options.command);
+    const timer = options.timer ?? DEFAULT_SUDO_TIMER;
+    const timeoutMs = options.timeoutMs ?? SUDO_PASSWORD_TIMEOUT_MS;
+    let timedOut = false;
+    const handle = timer.set(() => {
+        timedOut = true;
+        options.kill();
+    }, timeoutMs);
+    return {
+        announced: true,
+        disarm: () => timer.clear(handle),
+        timedOut: () => timedOut,
+    };
+}
+/** unguarded is the pass-through guard for a run nothing was armed for. */
+function unguarded() {
+    return {
+        announced: false,
+        disarm: () => { },
+        timedOut: () => false,
+    };
+}
+//# sourceMappingURL=sudo.js.map

package/packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-local-infer-core",
-  "version": "0.1.0",
+  "version": "0.1.4",
   "description": "Pure, framework-free domain model for the dsh local-inference plugin: ParameterSpec, HardwareProfile, EngineAdapter, VramEstimator, GuidelineEngine, DefaultsResolver, DshModelRegistrar, and SystemDepProvisioner primitives shared by every engine and model",
   "keywords": [
     "dsh",

package/packages/orchestrator/lib/config.d.ts

@@ -0,0 +1,63 @@
+/**
+ * The Orchestrator prompt store: the saved prompt file under
+ * ~/.dsh/local-infer/orchestrator.json, the shipped prompt.md default, and
+ * the in-memory holder the system-prompt section and the settings routes
+ * share. Every read sanitizes the file, so a by-hand edit never poisons the
+ * injected prompt. Mirrors the sanitize-on-read discipline of
+ * packages/ui/src/config.ts.
+ * @module dsh-plugin-local-infer/orchestrator/config
+ */
+/**
+ * orchestratorConfigPath names the file this package owns. It sits in the
+ * shared local-infer dir beside the ui config so one place holds everything
+ * the plugin persists.
+ */
+export declare function orchestratorConfigPath(): string;
+/**
+ * StoredOrchestratorConfig is the whole persisted shape: the saved prompt,
+ * where an empty string carries "no saved prompt" so the holder falls back
+ * to the shipped default.
+ */
+export interface StoredOrchestratorConfig {
+    prompt: string;
+}
+/**
+ * readOrchestratorConfig reads the saved prompt. A missing or broken file,
+ * or a prompt field that is not a string, reads as no saved prompt (empty),
+ * so a first open and a by-hand edit both land on the default instead of
+ * throwing.
+ */
+export declare function readOrchestratorConfig(): StoredOrchestratorConfig;
+/**
+ * writeOrchestratorConfig persists the prompt, creating the directory tree
+ * on first write the same way the ui config write does.
+ */
+export declare function writeOrchestratorConfig(config: StoredOrchestratorConfig): void;
+/**
+ * defaultOrchestratorPrompt returns the shipped prompt.md text read from the
+ * package root. The URL hop is relative to this module, so src/ and lib/
+ * depths both resolve one level up to the package root. The read is cached;
+ * an unreadable file yields '' without throwing.
+ */
+export declare function defaultOrchestratorPrompt(): string;
+/**
+ * getOrchestratorPrompt returns the effective prompt: the saved value when a
+ * non-empty one exists, otherwise the shipped default. The first call reads
+ * the file once and caches, so the system-prompt section pays no per-message
+ * disk read.
+ */
+export declare function getOrchestratorPrompt(): string;
+/**
+ * setOrchestratorPrompt persists the prompt and refreshes the holder, so the
+ * injected section picks the new text up without another file read. An empty
+ * save means "no saved prompt" and falls back to the default.
+ */
+export declare function setOrchestratorPrompt(prompt: string): void;
+/**
+ * hasSavedOrchestratorPrompt reports whether the file holds a saved prompt
+ * override. The empty string is the store's sentinel for "no saved prompt",
+ * so the settings routes read the flag through here instead of re-deriving
+ * the sentinel rule the holder already applies.
+ */
+export declare function hasSavedOrchestratorPrompt(): boolean;
+//# sourceMappingURL=config.d.ts.map