@the-open-engine/zeroshot 6.38.0 → 6.39.0

package/src/state-snapshotter.ts

@@ -0,0 +1,167 @@
+import crypto = require('crypto');
+import stateSnapshot = require('./state-snapshot');
+import normalization = require('./state-snapshot-normalization');
+
+interface SnapshotMessageBus {
+  subscribeTopics(topics: string[], handler: (message: unknown) => void): () => void;
+  findLast(query: { cluster_id: string; topic: string }): unknown;
+  publish(message: {
+    cluster_id: string;
+    topic: 'STATE_SNAPSHOT';
+    sender: 'state-snapshotter';
+    receiver: 'broadcast';
+    content: { text: string; data: object };
+  }): unknown;
+}
+
+interface StateSnapshotterOptions {
+  messageBus: SnapshotMessageBus;
+  clusterId: string;
+}
+
+type SnapshotState = ReturnType<typeof stateSnapshot.initStateFromIssue>;
+const SNAPSHOT_TOPICS = [
+  'ISSUE_OPENED',
+  'PLAN_READY',
+  'WORKER_PROGRESS',
+  'IMPLEMENTATION_READY',
+  'VALIDATION_RESULT',
+  'INVESTIGATION_COMPLETE',
+];
+
+function messageTimestamp(message: unknown): number {
+  const timestamp = normalization.asRecord(message)?.timestamp;
+  return timestamp ? Number(timestamp) : 0;
+}
+
+class StateSnapshotter {
+  messageBus: SnapshotMessageBus;
+  clusterId: string;
+  state: object | null;
+  lastHash: string | null;
+  unsubscribe: (() => void) | null;
+
+  constructor({ messageBus, clusterId }: StateSnapshotterOptions) {
+    this.messageBus = messageBus;
+    this.clusterId = clusterId;
+    this.state = null;
+    this.lastHash = null;
+    this.unsubscribe = null;
+  }
+
+  start(): void {
+    if (this.unsubscribe) {
+      return;
+    }
+
+    this._bootstrapFromLedger();
+
+    this.unsubscribe = this.messageBus.subscribeTopics(SNAPSHOT_TOPICS, (message: unknown) => {
+      if (normalization.asRecord(message)?.cluster_id !== this.clusterId) return;
+      this._handleMessage(message);
+    });
+  }
+
+  stop(): void {
+    if (!this.unsubscribe) return;
+    this.unsubscribe();
+    this.unsubscribe = null;
+  }
+
+  _bootstrapFromLedger(): void {
+    const existing = this.messageBus.findLast({
+      cluster_id: this.clusterId,
+      topic: 'STATE_SNAPSHOT',
+    });
+    const existingData = normalization.asRecord(normalization.asRecord(existing)?.content)?.data;
+
+    if (existingData && typeof existingData === 'object') {
+      this.state = existingData;
+      this.lastHash = this._hashState(this.state);
+      return;
+    }
+
+    const messages = SNAPSHOT_TOPICS.map((topic) =>
+      this.messageBus.findLast({ cluster_id: this.clusterId, topic })
+    ).filter(Boolean);
+
+    if (messages.length === 0) {
+      return;
+    }
+
+    messages.sort((left, right) => messageTimestamp(left) - messageTimestamp(right));
+
+    let state: object | null = null;
+    for (const message of messages) {
+      state = this._applyMessage(state, message);
+    }
+
+    if (state) {
+      this.state = state;
+      this._publishSnapshot(state);
+    }
+  }
+
+  _handleMessage(message: unknown): void {
+    const nextState = this._applyMessage(this.state, message);
+    if (!nextState) return;
+
+    this.state = nextState;
+    this._publishSnapshot(nextState);
+  }
+
+  _applyMessage(state: object | null, message: unknown): SnapshotState | object | null {
+    switch (normalization.asRecord(message)?.topic) {
+      case 'ISSUE_OPENED':
+        return state
+          ? stateSnapshot.applyIssueOpened(state, message)
+          : stateSnapshot.initStateFromIssue(message);
+      case 'PLAN_READY':
+        return stateSnapshot.applyPlanReady(state, message);
+      case 'WORKER_PROGRESS':
+        return stateSnapshot.applyWorkerProgress(state, message);
+      case 'IMPLEMENTATION_READY':
+        return stateSnapshot.applyImplementationReady(state, message);
+      case 'VALIDATION_RESULT':
+        return stateSnapshot.applyValidationResult(state, message);
+      case 'INVESTIGATION_COMPLETE':
+        return stateSnapshot.applyInvestigationComplete(state, message);
+      default:
+        return state;
+    }
+  }
+
+  _publishSnapshot(state: object): void {
+    const hash = this._hashState(state);
+    if (this._hashEquals(hash, this.lastHash)) {
+      return;
+    }
+    this.lastHash = hash;
+
+    this.messageBus.publish({
+      cluster_id: this.clusterId,
+      topic: 'STATE_SNAPSHOT',
+      sender: 'state-snapshotter',
+      receiver: 'broadcast',
+      content: {
+        text: stateSnapshot.renderStateSummary(state),
+        data: state,
+      },
+    });
+  }
+
+  _hashState(state: object): string {
+    const serialized = JSON.stringify(state);
+    return crypto.createHash('sha256').update(serialized).digest('hex');
+  }
+
+  _hashEquals(left: string | null, right: string | null): boolean {
+    if (!left || !right) return false;
+    const leftBuffer = Buffer.from(left, 'utf8');
+    const rightBuffer = Buffer.from(right, 'utf8');
+    if (leftBuffer.length !== rightBuffer.length) return false;
+    return crypto.timingSafeEqual(leftBuffer, rightBuffer);
+  }
+}
+
+export = StateSnapshotter;

package/src/sub-cluster-wrapper.js

@@ -15,6 +15,7 @@
 const LogicEngine = require('./logic-engine');
 const MessageBusBridge = require('./message-bus-bridge');
 const { DEFAULT_MAX_ITERATIONS } = require('./agent/agent-config');
+const { findMatchingTrigger } = require('./agent/agent-trigger-evaluator');
 const { bufferMessage, scheduleDrain, drainBufferedMessages } = require('./message-buffer');
 
 function normalizeParentTopicConfig(entry) {
@@ -217,19 +218,9 @@ class SubClusterWrapper {
    * @private
    */
   _findMatchingTrigger(message) {
-    if (!this.config.triggers) {
-      return null;
-    }
-
-    return this.config.triggers.find((trigger) => {
-      if (trigger.topic === '*' || trigger.topic === message.topic) {
-        return true;
-      }
-      if (trigger.topic.endsWith('*')) {
-        const prefix = trigger.topic.slice(0, -1);
-        return message.topic.startsWith(prefix);
-      }
-      return false;
+    return findMatchingTrigger({
+      triggers: this.config.triggers,
+      message,
     });
   }
 

package/src/task-run-model-args.js

@@ -1,38 +1,34 @@
-const { providerSupportsCapability } = require('../lib/provider-names');
-
-/**
- * Append a resolved model selection to a nested `zeroshot task run` invocation.
- *
- * Direct requests use the public, catalog-strict `--model` channel.
- * Provider-level selections carry only their level. The child must resolve the
- * concrete model again from its effective provider settings.
- *
- * @param {string[]} args
- * @param {Object|null|undefined} modelSpec
- * @param {'direct'|'provider-level'} [modelSpecSource]
- * @returns {string[]}
- */
+"use strict";
+function isUnknownRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function isProviderNamesModule(value) {
+    return isUnknownRecord(value) && typeof value.providerSupportsCapability === 'function';
+}
+const providerNames = require('../lib/provider-names');
+if (!isProviderNamesModule(providerNames)) {
+    throw new TypeError('provider-names must expose provider capability lookup');
+}
+const { providerSupportsCapability } = providerNames;
 function appendTaskRunModelArgs(args, modelSpec, modelSpecSource = 'direct') {
-  if (modelSpecSource === 'provider-level') {
-    if (!modelSpec?.level) {
-      throw new Error('Provider-level task model selections require a model level');
+    if (modelSpecSource === 'provider-level') {
+        if (!modelSpec?.level) {
+            throw new Error('Provider-level task model selections require a model level');
+        }
+        args.push('--model-level', modelSpec.level);
     }
-    args.push('--model-level', modelSpec.level);
-  } else if (modelSpec?.model) {
-    args.push('--model', modelSpec.model);
-  }
-
-  if (modelSpec?.reasoningEffort) {
-    args.push('--reasoning-effort', modelSpec.reasoningEffort);
-  }
-
-  return args;
+    else if (modelSpec?.model) {
+        args.push('--model', modelSpec.model);
+    }
+    if (modelSpec?.reasoningEffort) {
+        args.push('--reasoning-effort', modelSpec.reasoningEffort);
+    }
+    return args;
 }
-
 const ISOLATED_SETTINGS_FILE_ENV = 'ZEROSHOT_SETTINGS_FILE';
 const ISOLATED_SETTINGS_FILE_MARKER = 'ZEROSHOT_DOCKER_SETTINGS_FILE';
 const LEGACY_ISOLATED_PROVIDER_SETTINGS_ENV = 'ZEROSHOT_ISOLATED_PROVIDER_SETTINGS_JSON';
-const SETTINGS_BOOTSTRAP_SCRIPT = String.raw`
+const SETTINGS_BOOTSTRAP_SCRIPT = String.raw `
 const childProcess = require('node:child_process');
 const fs = require('node:fs');
 const os = require('node:os');
@@ -60,114 +56,81 @@ try {
   fs.rmSync(directory, { recursive: true, force: true });
 }
 `.trim();
-
-/**
- * Wrap an isolated task command with a Docker-only, temporary settings-file
- * bootstrap. The snapshot is a closed projection containing only an enabled
- * native-search control and, when needed, the selected OpenCode level/model.
- * It never contains credentials or caller-owned keys.
- *
- * @param {string[]} command
- * @param {{providerName: string, settings: Object, modelSpecSource: 'direct'|'provider-level', modelSpec: Object|null|undefined}} context
- * @returns {string[]}
- */
 function wrapTaskRunWithIsolatedSettings(command, context) {
-  const { providerName, settings, modelSpecSource, modelSpec } = context;
-  if (!providerSupportsCapability(providerName, 'webSearch')) return command;
-  const includesOpencodeModel =
-    providerName === 'opencode' && modelSpecSource === 'provider-level';
-  const snapshot = buildIsolatedSettingsSnapshot(
-    settings,
-    providerName,
-    includesOpencodeModel ? modelSpec : null
-  );
-  if (snapshot === null) return command;
-  return ['node', '-e', SETTINGS_BOOTSTRAP_SCRIPT, snapshot, ...command];
+    const { providerName, settings, modelSpecSource, modelSpec } = context;
+    if (!providerSupportsCapability(providerName, 'webSearch'))
+        return command;
+    const includesOpencodeModel = providerName === 'opencode' && modelSpecSource === 'provider-level';
+    const snapshot = buildIsolatedSettingsSnapshot(settings, providerName, includesOpencodeModel ? modelSpec : null);
+    if (snapshot === null)
+        return command;
+    return ['node', '-e', SETTINGS_BOOTSTRAP_SCRIPT, snapshot, ...command];
 }
-
 function buildIsolatedSettingsSnapshot(settings, providerName, opencodeModelSpec) {
-  const providerSettings = ownRecordValue(settings, 'providerSettings', 'settings') ?? {};
-  const selectedSettings = ownRecordValue(
-    providerSettings,
-    providerName,
-    'settings.providerSettings'
-  );
-  const webSearch = selectedSettings?.webSearch;
-  if (webSearch !== undefined && typeof webSearch !== 'boolean') {
-    throw permanentError(`settings.providerSettings.${providerName}.webSearch must be a boolean.`);
-  }
-
-  const snapshot = {};
-  if (webSearch === true) snapshot.webSearch = true;
-  if (opencodeModelSpec !== null) {
-    const level = opencodeModelSpec?.level;
-    if (!['level1', 'level2', 'level3'].includes(level)) {
-      throw permanentError(
-        'Provider-level isolated OpenCode selections require a valid model level.'
-      );
+    const providerSettings = ownRecordValue(settings, 'providerSettings', 'settings') ?? {};
+    const selectedSettings = ownRecordValue(providerSettings, providerName, 'settings.providerSettings');
+    const webSearch = selectedSettings?.webSearch;
+    if (webSearch !== undefined && typeof webSearch !== 'boolean') {
+        throw permanentError(`settings.providerSettings.${providerName}.webSearch must be a boolean.`);
     }
-
-    const levelOverrides = ownRecordValue(
-      selectedSettings,
-      'levelOverrides',
-      'settings.providerSettings.opencode'
-    );
-    const levelOverride = ownRecordValue(
-      levelOverrides,
-      level,
-      'settings.providerSettings.opencode.levelOverrides'
-    );
-    const configuredModel =
-      levelOverride && Object.prototype.hasOwnProperty.call(levelOverride, 'model')
+    const snapshot = {};
+    if (webSearch === true)
+        snapshot.webSearch = true;
+    if (opencodeModelSpec !== null) {
+        const levelOverrides = resolveIsolatedOpenCodeOverrides(selectedSettings, opencodeModelSpec);
+        if (levelOverrides !== undefined)
+            snapshot.levelOverrides = levelOverrides;
+    }
+    if (Object.keys(snapshot).length === 0)
+        return null;
+    return JSON.stringify({
+        providerSettings: {
+            [providerName]: snapshot,
+        },
+    });
+}
+function resolveIsolatedOpenCodeOverrides(selectedSettings, modelSpec) {
+    const level = modelSpec?.level;
+    if (level !== 'level1' && level !== 'level2' && level !== 'level3') {
+        throw permanentError('Provider-level isolated OpenCode selections require a valid model level.');
+    }
+    const levelOverrides = ownRecordValue(selectedSettings, 'levelOverrides', 'settings.providerSettings.opencode');
+    const levelOverride = ownRecordValue(levelOverrides, level, 'settings.providerSettings.opencode.levelOverrides');
+    const configuredModel = levelOverride && Object.prototype.hasOwnProperty.call(levelOverride, 'model')
         ? levelOverride.model
         : null;
     if (configuredModel !== null && typeof configuredModel !== 'string') {
-      throw permanentError(`Configured isolated OpenCode ${level} model must be a string or null.`);
+        throw permanentError(`Configured isolated OpenCode ${level} model must be a string or null.`);
     }
-    if (opencodeModelSpec.model !== configuredModel) {
-      throw permanentError(
-        `Provider-level model "${opencodeModelSpec.model}" does not match the effective isolated ${level} model "${configuredModel}".`
-      );
+    if (modelSpec?.model !== configuredModel) {
+        throw permanentError(`Provider-level model "${modelSpec?.model}" does not match ` +
+            `the effective isolated ${level} model "${configuredModel}".`);
     }
-    if (configuredModel !== null) {
-      snapshot.levelOverrides = {
-        [level]: { model: configuredModel },
-      };
-    }
-  }
-
-  if (Object.keys(snapshot).length === 0) return null;
-  return JSON.stringify({
-    providerSettings: {
-      [providerName]: snapshot,
-    },
-  });
+    return configuredModel === null ? undefined : { [level]: { model: configuredModel } };
 }
-
 function ownRecordValue(record, key, field) {
-  if (record === null || record === undefined) return undefined;
-  if (typeof record !== 'object' || Array.isArray(record)) {
-    throw permanentError(`${field} must be an object.`);
-  }
-  if (!Object.prototype.hasOwnProperty.call(record, key)) return undefined;
-  const value = record[key];
-  if (value === null || value === undefined) return undefined;
-  if (typeof value !== 'object' || Array.isArray(value)) {
-    throw permanentError(`${field}.${key} must be an object.`);
-  }
-  return value;
+    if (record === null || record === undefined)
+        return undefined;
+    if (!isUnknownRecord(record)) {
+        throw permanentError(`${field} must be an object.`);
+    }
+    if (!Object.prototype.hasOwnProperty.call(record, key))
+        return undefined;
+    const value = record[key];
+    if (value === null || value === undefined)
+        return undefined;
+    if (!isUnknownRecord(value)) {
+        throw permanentError(`${field}.${key} must be an object.`);
+    }
+    return value;
 }
-
 function permanentError(message) {
-  const error = new Error(message);
-  error.permanent = true;
-  return error;
+    return Object.assign(new Error(message), { permanent: true });
 }
-
 module.exports = {
-  ISOLATED_SETTINGS_FILE_ENV,
-  ISOLATED_SETTINGS_FILE_MARKER,
-  LEGACY_ISOLATED_PROVIDER_SETTINGS_ENV,
-  appendTaskRunModelArgs,
-  wrapTaskRunWithIsolatedSettings,
+    ISOLATED_SETTINGS_FILE_ENV,
+    ISOLATED_SETTINGS_FILE_MARKER,
+    LEGACY_ISOLATED_PROVIDER_SETTINGS_ENV,
+    appendTaskRunModelArgs,
+    wrapTaskRunWithIsolatedSettings,
 };

package/src/task-run-model-args.ts

@@ -0,0 +1,204 @@
+type ModelSpecSource = 'direct' | 'provider-level';
+type ModelLevel = 'level1' | 'level2' | 'level3';
+type UnknownRecord = Record<string, unknown>;
+
+interface ProviderNamesModule {
+  providerSupportsCapability(providerName: string, capability: string): boolean;
+}
+
+interface ModelSpec {
+  level?: ModelLevel;
+  model?: string | null;
+  reasoningEffort?: string;
+}
+
+interface IsolatedSettingsContext {
+  providerName: string;
+  settings: unknown;
+  modelSpecSource: ModelSpecSource;
+  modelSpec: ModelSpec | null | undefined;
+}
+
+interface IsolatedProviderSnapshot {
+  webSearch?: true;
+  levelOverrides?: Partial<Record<ModelLevel, { model: string }>>;
+}
+
+function isUnknownRecord(value: unknown): value is UnknownRecord {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function isProviderNamesModule(value: unknown): value is ProviderNamesModule {
+  return isUnknownRecord(value) && typeof value.providerSupportsCapability === 'function';
+}
+
+const providerNames: unknown = require('../lib/provider-names');
+if (!isProviderNamesModule(providerNames)) {
+  throw new TypeError('provider-names must expose provider capability lookup');
+}
+const { providerSupportsCapability } = providerNames;
+
+function appendTaskRunModelArgs(
+  args: string[],
+  modelSpec: ModelSpec | null | undefined,
+  modelSpecSource: ModelSpecSource = 'direct'
+): string[] {
+  if (modelSpecSource === 'provider-level') {
+    if (!modelSpec?.level) {
+      throw new Error('Provider-level task model selections require a model level');
+    }
+    args.push('--model-level', modelSpec.level);
+  } else if (modelSpec?.model) {
+    args.push('--model', modelSpec.model);
+  }
+
+  if (modelSpec?.reasoningEffort) {
+    args.push('--reasoning-effort', modelSpec.reasoningEffort);
+  }
+
+  return args;
+}
+
+const ISOLATED_SETTINGS_FILE_ENV = 'ZEROSHOT_SETTINGS_FILE';
+const ISOLATED_SETTINGS_FILE_MARKER = 'ZEROSHOT_DOCKER_SETTINGS_FILE';
+const LEGACY_ISOLATED_PROVIDER_SETTINGS_ENV = 'ZEROSHOT_ISOLATED_PROVIDER_SETTINGS_JSON';
+const SETTINGS_BOOTSTRAP_SCRIPT = String.raw`
+const childProcess = require('node:child_process');
+const fs = require('node:fs');
+const os = require('node:os');
+const path = require('node:path');
+
+const snapshot = process.argv[1];
+const command = process.argv[2];
+const args = process.argv.slice(3);
+const directory = fs.mkdtempSync(path.join(os.tmpdir(), 'zeroshot-isolated-settings-'));
+const settingsFile = path.join(directory, 'settings.json');
+
+try {
+  fs.writeFileSync(settingsFile, snapshot, { encoding: 'utf8', flag: 'wx', mode: 0o600 });
+  const result = childProcess.spawnSync(command, args, {
+    stdio: 'inherit',
+    env: {
+      ...process.env,
+      ${ISOLATED_SETTINGS_FILE_ENV}: settingsFile,
+      ${ISOLATED_SETTINGS_FILE_MARKER}: '1',
+    },
+  });
+  if (result.error) throw result.error;
+  process.exitCode = result.status === null ? 1 : result.status;
+} finally {
+  fs.rmSync(directory, { recursive: true, force: true });
+}
+`.trim();
+
+function wrapTaskRunWithIsolatedSettings(
+  command: string[],
+  context: IsolatedSettingsContext
+): string[] {
+  const { providerName, settings, modelSpecSource, modelSpec } = context;
+  if (!providerSupportsCapability(providerName, 'webSearch')) return command;
+  const includesOpencodeModel =
+    providerName === 'opencode' && modelSpecSource === 'provider-level';
+  const snapshot = buildIsolatedSettingsSnapshot(
+    settings,
+    providerName,
+    includesOpencodeModel ? modelSpec : null
+  );
+  if (snapshot === null) return command;
+  return ['node', '-e', SETTINGS_BOOTSTRAP_SCRIPT, snapshot, ...command];
+}
+
+function buildIsolatedSettingsSnapshot(
+  settings: unknown,
+  providerName: string,
+  opencodeModelSpec: ModelSpec | null | undefined
+): string | null {
+  const providerSettings = ownRecordValue(settings, 'providerSettings', 'settings') ?? {};
+  const selectedSettings = ownRecordValue(
+    providerSettings,
+    providerName,
+    'settings.providerSettings'
+  );
+  const webSearch = selectedSettings?.webSearch;
+  if (webSearch !== undefined && typeof webSearch !== 'boolean') {
+    throw permanentError(`settings.providerSettings.${providerName}.webSearch must be a boolean.`);
+  }
+
+  const snapshot: IsolatedProviderSnapshot = {};
+  if (webSearch === true) snapshot.webSearch = true;
+  if (opencodeModelSpec !== null) {
+    const levelOverrides = resolveIsolatedOpenCodeOverrides(selectedSettings, opencodeModelSpec);
+    if (levelOverrides !== undefined) snapshot.levelOverrides = levelOverrides;
+  }
+
+  if (Object.keys(snapshot).length === 0) return null;
+  return JSON.stringify({
+    providerSettings: {
+      [providerName]: snapshot,
+    },
+  });
+}
+
+
+function resolveIsolatedOpenCodeOverrides(
+  selectedSettings: UnknownRecord | undefined,
+  modelSpec: ModelSpec | undefined
+): IsolatedProviderSnapshot['levelOverrides'] {
+  const level = modelSpec?.level;
+  if (level !== 'level1' && level !== 'level2' && level !== 'level3') {
+    throw permanentError(
+      'Provider-level isolated OpenCode selections require a valid model level.'
+    );
+  }
+
+  const levelOverrides = ownRecordValue(
+    selectedSettings,
+    'levelOverrides',
+    'settings.providerSettings.opencode'
+  );
+  const levelOverride = ownRecordValue(
+    levelOverrides,
+    level,
+    'settings.providerSettings.opencode.levelOverrides'
+  );
+  const configuredModel =
+    levelOverride && Object.prototype.hasOwnProperty.call(levelOverride, 'model')
+      ? levelOverride.model
+      : null;
+  if (configuredModel !== null && typeof configuredModel !== 'string') {
+    throw permanentError(`Configured isolated OpenCode ${level} model must be a string or null.`);
+  }
+  if (modelSpec?.model !== configuredModel) {
+    throw permanentError(
+      `Provider-level model "${modelSpec?.model}" does not match ` +
+        `the effective isolated ${level} model "${configuredModel}".`
+    );
+  }
+  return configuredModel === null ? undefined : { [level]: { model: configuredModel } };
+}
+
+function ownRecordValue(record: unknown, key: string, field: string): UnknownRecord | undefined {
+  if (record === null || record === undefined) return undefined;
+  if (!isUnknownRecord(record)) {
+    throw permanentError(`${field} must be an object.`);
+  }
+  if (!Object.prototype.hasOwnProperty.call(record, key)) return undefined;
+  const value = record[key];
+  if (value === null || value === undefined) return undefined;
+  if (!isUnknownRecord(value)) {
+    throw permanentError(`${field}.${key} must be an object.`);
+  }
+  return value;
+}
+
+function permanentError(message: string): Error & { permanent: true } {
+  return Object.assign(new Error(message), { permanent: true as const });
+}
+
+export = {
+  ISOLATED_SETTINGS_FILE_ENV,
+  ISOLATED_SETTINGS_FILE_MARKER,
+  LEGACY_ISOLATED_PROVIDER_SETTINGS_ENV,
+  appendTaskRunModelArgs,
+  wrapTaskRunWithIsolatedSettings,
+};

package/src/task-runner.js

@@ -1,30 +1,10 @@
+"use strict";
 /**
- * TaskRunner - Strategy Pattern interface for executing provider tasks
- *
- * Implementations must provide a `run()` method that executes a task
- * with the given context and options. Different runners can implement various
- * execution strategies (CLI, mock responses, etc).
+ * TaskRunner - Strategy Pattern interface for executing provider tasks.
  */
 class TaskRunner {
-  /**
-   * Execute a provider task with the given context and options
-   *
-   * @param {string} _context - Full prompt/context for the provider to process
-   * @param {Object} _options - Execution options
-   * @param {string} _options.agentId - Identifier for this agent/task
-   * @param {string} _options.model - Model to use (provider-specific model id)
-   * @param {string} [_options.provider] - Provider to use (claude|codex|gemini)
-   * @param {object} [_options.modelSpec] - Resolved model spec (level/model/reasoningEffort)
-   * @param {string} [_options.outputFormat] - Output format ('text', 'json', 'stream-json')
-   * @param {Object} [_options.jsonSchema] - JSON schema for structured output validation
-   * @param {string} [_options.cwd] - Working directory for task execution
-   * @param {boolean} [_options.isolation] - Whether to run in isolated container
-   *
-   * @returns {Promise<{success: boolean, output: string, error: string|null, taskId?: string}>} Result object with success status, output, error message, and optional taskId
-   */
-  run(_context, _options) {
-    throw new Error('TaskRunner.run() not implemented');
-  }
+    run(_context, _options) {
+        throw new Error('TaskRunner.run() not implemented');
+    }
 }
-
 module.exports = TaskRunner;