@mjasnikovs/pi-task 0.38.28 → 0.38.30

package/dist/config/config.d.ts

@@ -7,26 +7,28 @@ export interface PiTaskConfig {
     enforceGuidelines: boolean;
     verifyWork: boolean;
     /**
-     * Run the four research workers concurrently instead of one at a time.
-     * DEFAULT OFF: serial was A/B-proven faster on a single-GPU local backend
-     * (concurrent streams split the GPU and slow each other ~4×, see
-     * phases.ts). Turn on only for a parallel-capable backend.
+     * Run the four research workers concurrently instead of one at a time
+     * (task/phases.ts). DEFAULT OFF. Serial is also what lets a worker read the
+     * sections finished before it — APIS builds on the FILES map, and gets
+     * nothing under the parallel branch. Measure your own backend before
+     * turning this on.
      */
     parallelResearchWorkers: boolean;
     /**
-     * Cache docs/search/fetch worker RESULTS for the duration of one /task-auto run
-     * so sibling tasks re-asking the same (package/url, query) reuse the first
-     * pipeline's digest instead of re-fetching (mx5 run-8 F10: the research phase
-     * burned 75 of 363 min largely re-fetching the same external docs across ~20
-     * siblings). Per-run isolated, external-only (project-source `.` lookups excluded),
-     * success-only. DEFAULT ON — the F10 live A/B showed no answer-quality regression
-     * (a cache hit serves byte-identical text to the first fetch; distinct queries never
-     * collide).
+     * Cache docs/search/fetch worker RESULTS for the duration of one /task-auto
+     * run, so sibling tasks re-asking the same (package/url, query) reuse the
+     * first pipeline's digest instead of re-fetching it. Per-run isolated,
+     * external-only (project-source `.` lookups are excluded), success-only.
+     *
+     * DEFAULT ON. A hit replays the stored text byte for byte. The key is the
+     * tool name plus the whole query — normalised for case and whitespace, so
+     * two spellings of one question share a digest, and nothing else does.
      */
     researchCache: boolean;
     /**
      * Which engine backs web search (pi-worker-search + freshness/enrichment).
-     * `exa` and `ddg` need no API key; `brave` needs BRAVE_SEARCH_API_KEY.
+     * `exa` and `ddg` need no API key; `brave` needs one (see
+     * SEARCH_PROVIDER_KEY_ENV in workers/search-types.ts).
      * DEFAULT `exa` so search works out of the box with zero configuration.
      */
     searchProvider: SearchProvider;
@@ -44,21 +46,21 @@ export interface PiTaskConfig {
     extensionWhitelist: string[];
     /**
      * Wall-clock ceiling (ms) on a SINGLE tool execution before the command
-     * watchdog steps in. Local models routinely run a command that never returns
-     * (e.g. `godot --headless` with no timeout, a dev server, a hung test) and
-     * the run wedges until the user manually aborts. pi's bash tool has an
-     * OPTIONAL timeout with NO default (bash.js), so a command the model didn't
-     * bound runs forever; this is the missing default.
+     * watchdog steps in. pi's bash tool declares its `timeout` parameter as
+     * "Timeout in seconds (optional, no default timeout)" and returns undefined
+     * when it is absent, so a command the model didn't bound runs forever. This
+     * is the missing default.
      *
      * ONE knob, TWO surfaces (shared/command-watchdog.ts): in the MAIN session
-     * the overrun call is cancelled via ctx.abort() (kills the tool's whole
-     * process tree) plus an auto-reminder turn; in the verify/fix GATE children
+     * the overrun fires ctx.abort(), which ends the whole agent operation — pi's
+     * bash tool answers that signal by killing the command's entire process
+     * tree — followed by an auto-reminder turn; in the verify/fix GATE children
      * (gate-deps.ts) the child is killed and re-spawned with a hint, the ceiling
-     * halving on repeat hangs. 0 = off — which unguards BOTH surfaces, gates
-     * included. Tool-agnostic: it arms on any tool execution, though in practice
-     * only bash runs long enough to trip it.
-     * DEFAULT 15 min: long enough for a real build/test suite, short enough that
-     * a true hang doesn't cost half an hour of dead time.
+     * halving per prior hang. 0 = off — which unguards BOTH surfaces, gates
+     * included. Tool-agnostic: it arms on any tool execution.
+     *
+     * The default is a compromise: it has to outlast a real build or test suite
+     * on the slowest machine you run this on, and still end a true hang.
      */
     requestTimeoutMs: number;
     /**
@@ -82,19 +84,21 @@ export interface PiTaskConfig {
      * aborts the request (shared/stream-watchdog.ts). A hung or silently-dropped
      * stream throws nothing, so neither the connection-error retry (needs a
      * reported error) nor the command watchdog (covers tool calls only) nor the
-     * child stall guard (a reachable endpoint is proof of life) can see it — mx5
-     * run 14 lost ~2.9h to three such hangs while the model server stayed healthy.
+     * child stall guard (a reachable endpoint is proof of life) can see it. The
+     * server stays healthy the whole time; only the stream is gone.
      *
-     * Measured as time since the LAST stream event of any kind, so a slow model
-     * emitting one token every 30s is never touched; only total silence counts.
-     * Suspended while a tool executes — that window is the command watchdog's.
+     * Measured as time since the LAST stream event of any kind, so a model that
+     * is merely slow is never touched however slow it is; only total silence
+     * counts. Suspended between `tool_execution_start` and the last call
+     * settling — that window belongs to the command watchdog.
      *
      * ONE knob, TWO surfaces: the MAIN session aborts the turn through the same
      * plumbing the command watchdog uses and posts a resume reminder; a CHILD is
      * killed and its result routed into the EXISTING connection-error retry.
      * 0 = off, on both surfaces.
-     * DEFAULT 10 min: local prompt processing on a 32k context legitimately emits
-     * nothing for minutes, so a 60-120s ceiling would kill healthy long prompts.
+     *
+     * The default is generous on purpose: a local backend can sit in prompt
+     * processing emitting nothing at all, and that silence is healthy.
      */
     streamInactivityMs: number;
     /**
@@ -114,33 +118,32 @@ export interface PiTaskConfig {
     yoloMode: boolean;
     /**
      * How much the run writes to its `.pi-tasks/*-debug.log` forensic trail
-     * (task/debug-log.ts). NOTHING in pi-task ever reads these files back —
-     * `task-io.ts` only globs `TASK_NNNN.md`, and auto-commit's trail snapshot
-     * copies bytes without parsing them — so this knob is behaviour-neutral by
-     * construction. It trades disk and repo noise against the ability to explain
-     * a run after it has finished.
+     * (task/debug-log.ts). Nothing in `src/` reads these files back —
+     * `task-io.ts` only matches `TASK_NNNN.md`, and auto-commit's trail snapshot
+     * reads every `.pi-tasks/` file as bytes and writes them back unparsed — so
+     * this knob is behaviour-neutral by construction. It trades disk and repo
+     * noise against the ability to explain a run after it has finished. The
+     * TESTS do read the trail back, which is why the test preload pins the
+     * config path away from the developer's own file.
      *
      * `full` is every line the child model emitted plus every tool result;
      * `events` keeps only decisions and guard actions; `off` writes nothing.
      *
      * DEFAULT `events`, not `off`, because the two levels are not the same kind
-     * of record. Measured on a real 247 KB `verify-debug.log` (IAR1, 1315 lines):
-     * the child's own output and the `↳` tool dumps are 85% of the bytes, while
-     * the `=== … ===` markers are 15% — and that 15% is the ONLY record of what
-     * the guards did (`GIT-STATE GUARD — child mutated graded state`, the
-     * write-capable child's `tree changes`, the FAIL reason). mx5 run 11's
-     * final-fix child deleted a source file; the tree-changes line is why that
-     * was findable at all. Silencing the chatter costs nothing; silencing the
-     * guard record makes the next incident unreconstructible, and a debug log
-     * cannot be recovered after the fact.
+     * of record. The child's own output and the `↳` tool dumps are bulk. The
+     * `=== … ===` markers are the only record of what the guards did — the
+     * git-state guard firing, a write-capable child's tree changes, a FAIL
+     * reason. Silencing the chatter costs nothing. Silencing the guard record
+     * makes the next incident unreconstructible, and a debug log cannot be
+     * recovered after the fact.
      */
     debugLogs: DebugLogLevel;
     /**
      * Which reasoning profile is in force. See config/reasoning.ts for the four
      * modes and the group vocabulary.
      *
-     * DEFAULT `default`, whose table ships all-`inherit` — so installing this
-     * version changes no child's argv until the user opts in.
+     * DEFAULT `default`, which uses the shipped per-group table. `off` and `on`
+     * override every group at once; `custom` reads the user's own table.
      */
     reasoningMode: ReasoningMode;
     /**
@@ -169,9 +172,10 @@ export declare const DEBUG_LOG_OPTIONS: readonly DebugLogLevel[];
  */
 export declare function sanitizeDebugLogs(value: unknown): DebugLogLevel;
 /**
- * The command-watchdog timeout choices offered by /task-config, newest-first in
- * the cycle order the picker shows. The stored config value is the ms number;
- * the label is display-only (mirrors the searchProvider label/value split).
+ * The command-watchdog timeout choices offered by /task-config, in the cycle
+ * order the picker shows: ascending, with `off` last. The stored config value is
+ * the ms number; the label is display-only (mirrors the searchProvider
+ * label/value split).
  */
 export declare const COMMAND_TIMEOUT_OPTIONS: ReadonlyArray<{
     label: string;
@@ -186,8 +190,8 @@ export declare function sanitizeRequestTimeoutMs(value: unknown): number;
 export declare function sanitizeCommandTimeoutExemptTools(value: unknown): string[];
 /**
  * The stream-watchdog choices offered by /task-config, in cycle order. Every
- * option is minutes, not seconds: the failure this guards costs hours, and the
- * legitimate silence it must tolerate (local prompt processing) is minutes.
+ * option is minutes, not seconds: the silence this must tolerate — a local
+ * backend in prompt processing — is itself measured in minutes.
  */
 export declare const STREAM_INACTIVITY_OPTIONS: ReadonlyArray<{
     label: string;
@@ -212,35 +216,31 @@ export declare function sanitizeExtensionWhitelist(value: unknown): string[];
  * How each setting's STORED value becomes a safe in-memory value — one loader per
  * key, keyed on the config's own type.
  *
- * `ConfigItem` (config/register.ts) already absorbed three of the four edits its
- * own header names: *"Adding one enum setting meant four coordinated edits (row,
- * format arm, parse arm, sanitizer) and NONE of them failed to compile if you
- * forgot it."* The sanitizer was the fourth, and it stayed behind in this file as
- * a hand-ordered statement ladder covering 7 of 14 keys. This is the mapped type
- * that closes it: a new field on `PiTaskConfig` is a compile error until it
- * declares how a hostile value becomes a safe one.
+ * The mapped type is the point: a new field on `PiTaskConfig` is a compile error
+ * until it declares how a hostile value becomes a safe one. Adding a field and
+ * nothing else fails tsc twice — once on DEFAULT_CONFIG, once here.
  */
 export declare const CONFIG_LOADERS: {
     [K in keyof PiTaskConfig]: (raw: unknown) => PiTaskConfig[K];
 };
 /**
- * Turn parsed config JSON into a `PiTaskConfig`. Pure — this is the seam the load
- * block used to have none of, so every hostile-value case was reachable only
- * through `getConfig()`, which reads the developer's own machine.
+ * Turn parsed config JSON into a `PiTaskConfig`. Pure, so every hostile-value
+ * case is reachable from a test without going through `getConfig()`, which reads
+ * whatever this machine has on disk.
  *
- * A non-object `raw` yields the defaults. That is not merely defensive: the old
- * block spread `parsed` directly, and `{...DEFAULT_CONFIG, ...'ab'}` produces
- * numeric index keys. Keys absent from the table are dropped rather than carried
- * into the config object.
+ * A non-object `raw` yields the defaults. Spreading a string instead would
+ * produce numeric index keys: `{...DEFAULT_CONFIG, ...'ab'}` gains `0` and `1`.
+ * Keys absent from the sanitizer table are dropped rather than carried into the
+ * config object.
  */
 export declare function loadConfig(raw: unknown): PiTaskConfig;
 /**
  * Where the saved config lives. `PI_TASK_CONFIG_PATH` overrides it.
  *
  * The override exists because this module loads the real file at import time,
- * which made every test that reads a config value depend on the developer's own
- * `~/.config/pi-task/config.json` — a machine-local `"debugLogs": "off"` failed
- * 12 tests here while CI (no config file at all) stayed green. The test preload
+ * which makes every test that reads a config value depend on the developer's own
+ * `~/.config/pi-task/config.json` — a machine-local `"debugLogs": "off"` is
+ * enough to fail the tests that read `plan-debug.log` back. The test preload
  * points this at a path under the tmp dir that never exists, so tests always see
  * DEFAULT_CONFIG. Read once at module eval: the preload runs before any import.
  */

package/dist/config/config.js

@@ -23,9 +23,10 @@ export function sanitizeDebugLogs(value) {
         : DEFAULT_DEBUG_LOGS;
 }
 /**
- * The command-watchdog timeout choices offered by /task-config, newest-first in
- * the cycle order the picker shows. The stored config value is the ms number;
- * the label is display-only (mirrors the searchProvider label/value split).
+ * The command-watchdog timeout choices offered by /task-config, in the cycle
+ * order the picker shows: ascending, with `off` last. The stored config value is
+ * the ms number; the label is display-only (mirrors the searchProvider
+ * label/value split).
  */
 export const COMMAND_TIMEOUT_OPTIONS = [
     { label: '5 min', ms: 5 * 60_000 },
@@ -63,8 +64,8 @@ export function sanitizeCommandTimeoutExemptTools(value) {
 }
 /**
  * The stream-watchdog choices offered by /task-config, in cycle order. Every
- * option is minutes, not seconds: the failure this guards costs hours, and the
- * legitimate silence it must tolerate (local prompt processing) is minutes.
+ * option is minutes, not seconds: the silence this must tolerate — a local
+ * backend in prompt processing — is itself measured in minutes.
  */
 export const STREAM_INACTIVITY_OPTIONS = [
     { label: '5 min', ms: 5 * 60_000 },
@@ -93,8 +94,6 @@ export const DEFAULT_CONFIG = {
     enforceGuidelines: true,
     verifyWork: true,
     parallelResearchWorkers: false,
-    // ON: the F10 live A/B showed no answer-quality regression (fidelity 3/3, quality
-    // 3/3, 0 collisions; ~14.5s of repeated docs lookups collapse to 0ms on a hit).
     researchCache: true,
     searchProvider: 'exa',
     extensionWhitelist: [],
@@ -103,12 +102,11 @@ export const DEFAULT_CONFIG = {
     streamInactivityMs: DEFAULT_STREAM_INACTIVITY_MS,
     // OFF: auto-answering is for unattended throwaway runs only.
     yoloMode: false,
-    // EVENTS: the model chatter is 85% of the bytes and nobody reads it; the
-    // guard/verdict markers are the 15% that explains a failed run.
+    // EVENTS: the model chatter is bulk nobody reads; the guard and verdict
+    // markers are what explains a failed run.
     debugLogs: DEFAULT_DEBUG_LOGS,
-    // DEFAULT: the measured per-group table, which currently holds `inherit` in
-    // every cell. Every child's argv is byte-identical to the version before
-    // reasoning profiles existed until a cell is filled in by an A/B.
+    // DEFAULT: the shipped per-group table. A cell left at `inherit` emits no
+    // --thinking flag, so that child keeps the host's own level.
     reasoningMode: 'default',
     reasoningLevels: { ...DEFAULT_REASONING_TABLE }
 };
@@ -123,12 +121,9 @@ export function sanitizeExtensionWhitelist(value) {
 }
 /**
  * A boolean setting's loader. Only a REAL boolean counts; anything else falls
- * back to the shipped default.
- *
- * This is `yoloMode`'s guard, generalised. Its comment — *"a hand-edited
- * `"yoloMode": "false"` is a truthy string"* — was true verbatim of the other
- * seven booleans, none of which had it, so a stale `"verifyWork": "off"` reached
- * `getConfig().verifyWork` as truthy and a `"autoCommit": 0` reached it as falsy.
+ * back to the shipped default — a hand-edited `"verifyWork": "off"` is a truthy
+ * string and a `"autoCommit": 0` is a falsy number, and neither may decide a
+ * setting.
  */
 function asBoolean(key) {
     return raw => (typeof raw === 'boolean' ? raw : DEFAULT_CONFIG[key]);
@@ -137,13 +132,9 @@ function asBoolean(key) {
  * How each setting's STORED value becomes a safe in-memory value — one loader per
  * key, keyed on the config's own type.
  *
- * `ConfigItem` (config/register.ts) already absorbed three of the four edits its
- * own header names: *"Adding one enum setting meant four coordinated edits (row,
- * format arm, parse arm, sanitizer) and NONE of them failed to compile if you
- * forgot it."* The sanitizer was the fourth, and it stayed behind in this file as
- * a hand-ordered statement ladder covering 7 of 14 keys. This is the mapped type
- * that closes it: a new field on `PiTaskConfig` is a compile error until it
- * declares how a hostile value becomes a safe one.
+ * The mapped type is the point: a new field on `PiTaskConfig` is a compile error
+ * until it declares how a hostile value becomes a safe one. Adding a field and
+ * nothing else fails tsc twice — once on DEFAULT_CONFIG, once here.
  */
 export const CONFIG_LOADERS = {
     remote: asBoolean('remote'),
@@ -166,14 +157,14 @@ export const CONFIG_LOADERS = {
     reasoningLevels: sanitizeReasoningLevels
 };
 /**
- * Turn parsed config JSON into a `PiTaskConfig`. Pure — this is the seam the load
- * block used to have none of, so every hostile-value case was reachable only
- * through `getConfig()`, which reads the developer's own machine.
+ * Turn parsed config JSON into a `PiTaskConfig`. Pure, so every hostile-value
+ * case is reachable from a test without going through `getConfig()`, which reads
+ * whatever this machine has on disk.
  *
- * A non-object `raw` yields the defaults. That is not merely defensive: the old
- * block spread `parsed` directly, and `{...DEFAULT_CONFIG, ...'ab'}` produces
- * numeric index keys. Keys absent from the table are dropped rather than carried
- * into the config object.
+ * A non-object `raw` yields the defaults. Spreading a string instead would
+ * produce numeric index keys: `{...DEFAULT_CONFIG, ...'ab'}` gains `0` and `1`.
+ * Keys absent from the sanitizer table are dropped rather than carried into the
+ * config object.
  */
 export function loadConfig(raw) {
     if (typeof raw !== 'object' || raw === null || Array.isArray(raw)) {
@@ -194,9 +185,9 @@ export function loadConfig(raw) {
  * Where the saved config lives. `PI_TASK_CONFIG_PATH` overrides it.
  *
  * The override exists because this module loads the real file at import time,
- * which made every test that reads a config value depend on the developer's own
- * `~/.config/pi-task/config.json` — a machine-local `"debugLogs": "off"` failed
- * 12 tests here while CI (no config file at all) stayed green. The test preload
+ * which makes every test that reads a config value depend on the developer's own
+ * `~/.config/pi-task/config.json` — a machine-local `"debugLogs": "off"` is
+ * enough to fail the tests that read `plan-debug.log` back. The test preload
  * points this at a path under the tmp dir that never exists, so tests always see
  * DEFAULT_CONFIG. Read once at module eval: the preload runs before any import.
  */

package/dist/config/extension-list.d.ts

@@ -1,10 +1,11 @@
 /**
  * Enumerates the host's installed pi extensions for the /task-config whitelist
- * (GitHub issue #4) using pi's OWN resolver — the same DefaultPackageManager
- * the host runtime discovers extensions with — so the menu always mirrors what
- * `pi list`/discovery would load: install a package and it appears, uninstall
- * it and it vanishes (a stale whitelist entry is then skipped at spawn time by
- * extensionArgs' existence filter, never fatal).
+ * (GitHub issue #4) using pi's OWN resolver: the call below is the same
+ * `new DefaultPackageManager(...)` plus `resolve(() => "skip")` that pi's own
+ * startup makes (cli/startup-ui.js). So the menu shows what the host would
+ * load — install a package and it appears, uninstall it and it vanishes (a
+ * stale whitelist entry is then skipped at spawn time by extensionArgs'
+ * existence filter, never fatal).
  */
 export interface InstalledExtension {
     /** Absolute entry-point path — the whitelist identity AND the `-e` value. */

package/dist/config/extension-list.js

@@ -44,8 +44,9 @@ export async function listInstalledExtensions(opts) {
     const selfRoot = opts.selfRoot ?? selfPackageRoot();
     const settingsManager = SettingsManager.create(opts.cwd, agentDir);
     const pm = new DefaultPackageManager({ cwd: opts.cwd, agentDir, settingsManager });
-    // "skip": a package in settings whose install dir is missing must not
-    // trigger an interactive install prompt from inside a config menu.
+    // "skip": a package in settings whose install dir is missing is passed over.
+    // Without this callback pi installs it instead, which a config menu must
+    // never do on the user's behalf.
     const resolved = await pm.resolve(() => Promise.resolve('skip'));
     const out = [];
     for (const r of resolved.extensions) {

package/dist/config/reasoning-args.d.ts

@@ -1,12 +1,13 @@
 /**
  * The live-config bridge for reasoning profiles: group in, argv fragment out.
  *
- * Separate from reasoning.ts because that module must stay import-free — see its
- * header. This file is the one hop that reads `getConfig()`, so it imports both
- * and neither imports it back: a tree, not a cycle.
+ * Separate from reasoning.ts because that module must take no import with a
+ * runtime side effect — see its header. The `getConfig()` read lives here
+ * instead: this file imports both, and nothing in config/ imports it back, so
+ * the graph stays a tree.
  *
  * Read PER CALL, never cached at module scope, so a /task-config change lands on
- * the next child without a restart — the same contract childBaseArgs states.
+ * the next child without a restart. Same contract `childBaseArgs` keeps.
  */
 import { type PiTaskConfig } from './config.js';
 import { type ReasoningGroup } from './reasoning.js';
@@ -14,8 +15,9 @@ import { type ReasoningGroup } from './reasoning.js';
  * The `['--thinking', level]` fragment for a group, or `[]` when the group is
  * `inherit` and the child should keep falling back to settings.json.
  *
- * This is the ONLY function the argv builders call. They never read config
- * themselves — an argv builder that resolves its own policy is one that cannot
- * be told to do something else, which is how childBaseArgs became universal.
+ * Every argv builder calls this rather than reading config itself. The two
+ * callers that skip it are not argv builders: the host-session turn
+ * (implementation-thinking.ts) and the settings UI (register.ts) both need the
+ * level itself, not a flag, so they call `resolveReasoning` directly.
  */
 export declare function groupThinkingArgs(group: ReasoningGroup, cfg?: PiTaskConfig): string[];

package/dist/config/reasoning-args.js

@@ -1,12 +1,13 @@
 /**
  * The live-config bridge for reasoning profiles: group in, argv fragment out.
  *
- * Separate from reasoning.ts because that module must stay import-free — see its
- * header. This file is the one hop that reads `getConfig()`, so it imports both
- * and neither imports it back: a tree, not a cycle.
+ * Separate from reasoning.ts because that module must take no import with a
+ * runtime side effect — see its header. The `getConfig()` read lives here
+ * instead: this file imports both, and nothing in config/ imports it back, so
+ * the graph stays a tree.
  *
  * Read PER CALL, never cached at module scope, so a /task-config change lands on
- * the next child without a restart — the same contract childBaseArgs states.
+ * the next child without a restart. Same contract `childBaseArgs` keeps.
  */
 import { getConfig } from './config.js';
 import { resolveReasoning, thinkingArgs } from './reasoning.js';
@@ -14,13 +15,14 @@ import { resolveReasoning, thinkingArgs } from './reasoning.js';
  * The `['--thinking', level]` fragment for a group, or `[]` when the group is
  * `inherit` and the child should keep falling back to settings.json.
  *
- * This is the ONLY function the argv builders call. They never read config
- * themselves — an argv builder that resolves its own policy is one that cannot
- * be told to do something else, which is how childBaseArgs became universal.
+ * Every argv builder calls this rather than reading config itself. The two
+ * callers that skip it are not argv builders: the host-session turn
+ * (implementation-thinking.ts) and the settings UI (register.ts) both need the
+ * level itself, not a flag, so they call `resolveReasoning` directly.
  */
 export function groupThinkingArgs(group, cfg) {
-    // The default is EVALUATED HERE, per call, which is the contract this module
-    // exists to keep. Hoisting the read to module scope would leave every test
-    // green, so the parameter is what makes the contract assertable at all.
+    // The default is evaluated HERE, per call. Hoisting the read to module scope
+    // would leave every test green, so the optional parameter is what makes the
+    // per-call contract assertable.
     return thinkingArgs(resolveReasoning(group, cfg ?? getConfig()));
 }