dsh-harbor-evolution 0.7.0 → 0.7.2

package/README.md

@@ -14,10 +14,10 @@ npx --yes dsh-harbor-evolution@latest setup --project-root "$PWD"
 
 The setup command installs both required runtimes:
 
-- `harbor-dsh-evolution==0.7.0` in a managed Python environment.
-- `dsh-harbor-evolution@0.7.0` in the selected DSH profile.
+- `harbor-dsh-evolution==0.7.2` in a managed Python environment.
+- `dsh-harbor-evolution@0.7.2` in the selected DSH profile.
 
-It then stores the absolute Harbor executable paths and `projectRoot` in the profile's `harbor-evolution` block and verifies the integration. Existing unrelated profile entries are preserved, and rerunning setup updates the same block.
+It then stores the absolute Harbor executable paths and a fallback `projectRoot` in the profile's `harbor-evolution` block and verifies the integration. Agent Tool calls always use the calling session's absolute working directory as their project root; the configured value remains the Web Workbench and non-Agent fallback. Existing unrelated profile entries are preserved, and rerunning setup updates the same block.
 
 The default profile is `web`. Use `--profile headless` only when that is the profile you actually run. See all options with:
 
@@ -57,6 +57,12 @@ The Web UI is intentionally read-only. Starting an evaluation or deciding promot
 
 A direct evaluation requires `candidatePath`, `datasetPath`, `stackPath`, and explicit `mode`; `promotion-eligible` additionally requires `policyPath`. Prefer the Skill because it will not run or compare Jobs until the material identities and evaluation contract are resolved.
 
+## Candidate model binding
+
+Before each Job, the Plugin snapshots the current DSH Agent selection—provider, model, and reasoning effort—then starts a per-Job local Model Broker. The Candidate uses the temporary `dsh-host` adapter through `dsh-host-broker` / `dsh-host-model-gateway/v1`; it receives only a short-lived Job capability file, never GPT Auth, Codex OAuth, or an upstream API key.
+
+`harbor_eval_run`, `harbor_context_preview`, and `harbor_evolution_doctor` inherit that selection by default. Advanced callers can override `candidateProvider` and `candidateModel` only as a pair, plus an optional `candidateReasoningEffort`. `openai-codex` performs a GPT Auth sign-in check before Harbor starts. The resulting model binding is part of Context v2 comparison identity, so any provider/model/reasoning change requires a new baseline.
+
 `harbor_eval_result` defaults to the stable Summary. Use `view=job`, `view=dataset`, `view=progress`, `view=trial` plus a returned `trialId`, or `view=governance` to inspect sanitized instructions, generated output, evidence, and evaluator source without coupling the Agent to artifact file paths.
 
 ## What setup writes
@@ -73,7 +79,7 @@ The selected profile receives one id-targeted override:
     pythonPath: ""
 ```
 
-Keep `pythonPath` empty for the published Python package. `candidatePath`, `datasetPath`, `jobPath`, and `policyPath` are constrained to `projectRoot`.
+Keep `pythonPath` empty for the published Python package. For Agent Tool calls, `projectRoot` is replaced by the calling session's working directory for that call. `candidatePath`, `datasetPath`, `jobPath`, and `policyPath` remain constrained to that request-local root, so concurrent sessions cannot redirect each other's Harbor operations.
 
 For source development from the repository:
 

package/index.js

@@ -5,11 +5,12 @@ import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 
 import { loadBundledSkill } from './lib/official-skill.js'
+import { CandidateModelRuntime } from './lib/model-runtime.js'
 import { EvolutionService } from './lib/service.js'
 import { installDashboardWeb } from './lib/web.js'
 
 export const name = 'harbor-evolution'
-export const inject = ['tools', 'skills']
+export const inject = ['tools', 'skills', 'llm', 'agentDefaultModel']
 
 const packageDir = path.dirname(fileURLToPath(import.meta.url))
 const checkoutPythonPackage = path.resolve(packageDir, '../harbor-plugin')
@@ -30,6 +31,13 @@ export const Config = Schema.object({
   pluginImportPath: Schema.string().default('dsh-evolution'),
   pythonPath: Schema.string().default(''),
   timeoutMs: Schema.number().default(1800000),
+  candidateProvider: Schema.string().default(''),
+  candidateModel: Schema.string().default(''),
+  candidateReasoningEffort: Schema.string().default(''),
+  modelBrokerBindHost: Schema.string().default('127.0.0.1'),
+  modelBrokerAdvertisedHost: Schema.string().default('host.docker.internal'),
+  modelBrokerMaxRequests: Schema.number().min(1).default(1000),
+  modelBrokerMaxRequestBytes: Schema.number().min(1024).default(33554432),
 })
 
 function jsonTool(definition, execute) {
@@ -39,12 +47,20 @@ function jsonTool(definition, execute) {
       schema: { type: 'string' },
       render: (_args, value) => [{ type: 'text', text: value }],
     },
-    async execute(args) {
-      return JSON.stringify(await execute(args), null, 2)
+    async execute(args, exec) {
+      return JSON.stringify(await execute(args, exec), null, 2)
     },
   })
 }
 
+function toolProjectRoot(exec) {
+  const cwd = exec?.agent?.session?.header?.cwd
+  if (typeof cwd !== 'string' || !path.isAbsolute(cwd)) {
+    throw new Error('Harbor tools require an Agent session with an absolute working directory')
+  }
+  return path.resolve(cwd)
+}
+
 export function apply(ctx, config) {
   const resolved = {
     ...config,
@@ -57,7 +73,13 @@ export function apply(ctx, config) {
         : ''
     ),
   }
-  const service = new EvolutionService(resolved, { pluginVersion: packageJson.version })
+  const modelRuntime = new CandidateModelRuntime(ctx, resolved)
+  const metadata = { pluginVersion: packageJson.version }
+  const service = new EvolutionService(resolved, metadata, modelRuntime)
+  const serviceForTool = exec => new EvolutionService({
+    ...resolved,
+    projectRoot: toolProjectRoot(exec),
+  }, metadata, modelRuntime)
 
   ctx.skills.register(loadBundledSkill())
   installDashboardWeb(ctx, service)
@@ -70,7 +92,7 @@ export function apply(ctx, config) {
       candidateId: { type: 'string' },
       version: { type: 'string' },
     },
-  }, args => service.snapshot(args)))
+  }, (args, exec) => serviceForTool(exec).snapshot(args)))
 
   ctx.tools.register(jsonTool({
     name: 'harbor_evolution_init',
@@ -92,7 +114,7 @@ export function apply(ctx, config) {
       policyVersion: { type: 'string', required: true },
       minImprovement: { type: 'number', required: true },
     },
-  }, args => service.initialize(args)))
+  }, (args, exec) => serviceForTool(exec).initialize(args)))
 
   ctx.tools.register(jsonTool({
     name: 'harbor_evolution_doctor',
@@ -103,8 +125,11 @@ export function apply(ctx, config) {
       stackPath: { type: 'string', required: true },
       policyPath: { type: 'string' },
       mode: { type: 'string', required: true },
+      candidateProvider: { type: 'string', description: 'Optional Candidate provider. Supply it together with candidateModel; defaults to the current DSH Agent model.' },
+      candidateModel: { type: 'string' },
+      candidateReasoningEffort: { type: 'string' },
     },
-  }, args => service.doctor(args)))
+  }, (args, exec) => serviceForTool(exec).doctor(args)))
 
   ctx.tools.register(jsonTool({
     name: 'harbor_dataset_validate',
@@ -112,7 +137,7 @@ export function apply(ctx, config) {
     parameters: {
       datasetPath: { type: 'string', required: true },
     },
-  }, args => service.validateDataset(args)))
+  }, (args, exec) => serviceForTool(exec).validateDataset(args)))
 
   ctx.tools.register(jsonTool({
     name: 'harbor_context_preview',
@@ -124,8 +149,11 @@ export function apply(ctx, config) {
       datasetPath: { type: 'string', required: true },
       stackPath: { type: 'string', required: true },
       mode: { type: 'string', required: true },
+      candidateProvider: { type: 'string', description: 'Optional Candidate provider. Supply it together with candidateModel; defaults to the current DSH Agent model.' },
+      candidateModel: { type: 'string' },
+      candidateReasoningEffort: { type: 'string' },
     },
-  }, args => service.previewContext(args)))
+  }, (args, exec) => serviceForTool(exec).previewContext(args)))
 
   ctx.tools.register(jsonTool({
     name: 'harbor_eval_run',
@@ -139,8 +167,11 @@ export function apply(ctx, config) {
       mode: { type: 'string', required: true },
       policyPath: { type: 'string' },
       jobName: { type: 'string' },
+      candidateProvider: { type: 'string', description: 'Optional Candidate provider. Supply it together with candidateModel; defaults to the current DSH Agent model and is frozen before the Job starts.' },
+      candidateModel: { type: 'string' },
+      candidateReasoningEffort: { type: 'string' },
     },
-  }, args => service.run(args)))
+  }, (args, exec) => serviceForTool(exec).run(args)))
 
   ctx.tools.register(jsonTool({
     name: 'harbor_eval_result',
@@ -152,7 +183,7 @@ export function apply(ctx, config) {
       compareJob: { type: 'string', description: 'Optional previous Job for view=governance impact analysis' },
       since: { type: 'string', description: 'Optional ISO timestamp for incremental progress changes' },
     },
-  }, args => service.result(args)))
+  }, (args, exec) => serviceForTool(exec).result(args)))
 
   ctx.tools.register(jsonTool({
     name: 'harbor_evaluator_inspect',
@@ -160,7 +191,7 @@ export function apply(ctx, config) {
     parameters: {
       stackPath: { type: 'string', description: 'Defaults to .harbor/evaluation-stack.yml' },
     },
-  }, args => service.evaluatorInspect(args)))
+  }, (args, exec) => serviceForTool(exec).evaluatorInspect(args)))
 
   ctx.tools.register(jsonTool({
     name: 'harbor_evaluator_update',
@@ -173,7 +204,7 @@ export function apply(ctx, config) {
       newEvaluatorVersion: { type: 'string', required: true },
       newStackVersion: { type: 'string', required: true },
     },
-  }, args => service.evaluator(args)))
+  }, (args, exec) => serviceForTool(exec).evaluator(args)))
 
   ctx.tools.register(jsonTool({
     name: 'harbor_ground_truth_init',
@@ -187,7 +218,7 @@ export function apply(ctx, config) {
       provenance: { type: 'string', required: true },
       criteria: { type: 'string', required: true, description: 'Comma-separated criterion ids' },
     },
-  }, args => service.groundTruthInitialize(args)))
+  }, (args, exec) => serviceForTool(exec).groundTruthInitialize(args)))
 
   ctx.tools.register(jsonTool({
     name: 'harbor_evaluator_meta_evaluate',
@@ -197,7 +228,7 @@ export function apply(ctx, config) {
       observationsPath: { type: 'string', required: true },
       outputPath: { type: 'string', description: 'Defaults to .harbor/meta-evaluation-report.json' },
     },
-  }, args => service.evaluatorMetaEvaluate(args)))
+  }, (args, exec) => serviceForTool(exec).evaluatorMetaEvaluate(args)))
 
   ctx.tools.register(jsonTool({
     name: 'harbor_candidate_compare',
@@ -207,5 +238,5 @@ export function apply(ctx, config) {
       candidateJob: { type: 'string', required: true },
       policyPath: { type: 'string', required: true },
     },
-  }, args => service.compare(args)))
+  }, (args, exec) => serviceForTool(exec).compare(args)))
 }

package/lib/candidate.js

@@ -4,7 +4,7 @@ import path from 'node:path'
 
 export const MANIFEST_NAME = 'candidate-manifest.json'
 const DIGEST_PREFIX = Buffer.from('harbor-dsh-candidate-v1\0')
-const EXCLUDED_DIRS = new Set(['.git', 'node_modules', '__pycache__'])
+const EXCLUDED_DIRS = new Set(['.git', 'node_modules', '__pycache__', '.harbor-runtime'])
 const EXCLUDED_FILES = new Set([MANIFEST_NAME, '.DS_Store'])
 const LOCKFILES = ['package-lock.json', 'pnpm-lock.yaml', 'yarn.lock', 'bun.lock', 'bun.lockb']
 const CREDENTIAL_FILES = new Set([
@@ -57,6 +57,12 @@ export async function computeCandidate(candidateDir) {
 }
 
 async function validateCandidateContract(root) {
+  try {
+    await stat(path.join(root, '.harbor-runtime'))
+    throw new Error('Candidate must not contain the reserved .harbor-runtime path')
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error
+  }
   for (const required of ['cordis.yml', 'package.json']) {
     try {
       if (!(await stat(path.join(root, required))).isFile()) throw new Error()

package/lib/evolution.js

@@ -119,6 +119,19 @@ function strictInputs(config, args) {
   return { projectRoot, candidate, dataset, stack, jobs, mode, policy }
 }
 
+function candidateModelCliArgs(binding) {
+  if (!binding?.provider || !binding?.model) throw new Error('Candidate model binding is required')
+  return [
+    '--candidate-model-provider', binding.provider,
+    '--candidate-model', binding.model,
+    ...(binding.reasoning_effort === undefined
+      ? []
+      : ['--candidate-reasoning-effort', binding.reasoning_effort]),
+    '--candidate-model-transport', binding.transport,
+    '--candidate-model-protocol', binding.protocol,
+  ]
+}
+
 export async function validateDataset(config, args) {
   const dataset = resolveWithin(config.projectRoot, args.datasetPath, 'datasetPath')
   return cliJson(config, ['dataset', 'validate', dataset, '--project-root', config.projectRoot], { allowedExitCodes: [0, 2] })
@@ -157,11 +170,12 @@ export async function previewContext(config, args) {
     '--stack', inputs.stack,
     '--jobs-dir', inputs.jobs,
     '--mode', inputs.mode,
+    ...candidateModelCliArgs(args.candidateModelBinding),
   ])
   return { manifest, ...preview }
 }
 
-export async function runEvaluation(config, args) {
+export async function runEvaluation(config, args, modelRuntime) {
   const manifest = await snapshot(config, args)
   const inputs = strictInputs(config, args)
   const datasetValidation = await validateDataset(config, args)
@@ -176,6 +190,7 @@ export async function runEvaluation(config, args) {
     'context', 'preview', '--project-root', inputs.projectRoot,
     '--candidate', inputs.candidate, '--dataset', inputs.dataset,
     '--stack', inputs.stack, '--jobs-dir', inputs.jobs, '--mode', inputs.mode,
+    ...candidateModelCliArgs(args.candidateModelBinding),
   ])
   const jobName = args.jobName ?? makeJobName(manifest)
   if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/.test(jobName)) throw new Error('jobName contains unsupported characters')
@@ -186,6 +201,8 @@ export async function runEvaluation(config, args) {
     '--ak', `candidate_path=${inputs.candidate}`,
     '--ak', `candidate_version=${manifest.version}`,
     '--ak', `candidate_digest=${manifest.digest}`,
+    '--ak', `candidate_model_provider=${args.candidateModelBinding.provider}`,
+    '--ak', `candidate_model=${args.candidateModelBinding.model}`,
     '--job-name', jobName,
     '--jobs-dir', inputs.jobs,
     '--plugin', config.pluginImportPath,
@@ -194,22 +211,47 @@ export async function runEvaluation(config, args) {
     '--plugin-kwarg', `stack_path=${inputs.stack}`,
     '--plugin-kwarg', `project_root=${inputs.projectRoot}`,
     '--plugin-kwarg', `mode=${inputs.mode}`,
+    '--plugin-kwarg', `candidate_model_provider=${args.candidateModelBinding.provider}`,
+    '--plugin-kwarg', `candidate_model=${args.candidateModelBinding.model}`,
+    '--plugin-kwarg', `candidate_model_transport=${args.candidateModelBinding.transport}`,
+    '--plugin-kwarg', `candidate_model_protocol=${args.candidateModelBinding.protocol}`,
   ]
+  if (args.candidateModelBinding.reasoning_effort !== undefined) {
+    harborArgs.push('--ak', `candidate_reasoning_effort=${args.candidateModelBinding.reasoning_effort}`)
+    harborArgs.push('--plugin-kwarg', `candidate_reasoning_effort=${args.candidateModelBinding.reasoning_effort}`)
+  }
   if (inputs.policy) harborArgs.push('--plugin-kwarg', `policy_path=${inputs.policy}`)
-  const processResult = await runProcess(config.harborBin, harborArgs, {
-    cwd: config.projectRoot,
-    timeoutMs: config.timeoutMs,
-    env: { ...process.env, ...(config.pythonPath ? { PYTHONPATH: config.pythonPath } : {}) },
+  const lease = await modelRuntime.openLease(args.candidateModelBinding, {
+    candidateDigest: manifest.digest,
+    jobName,
   })
-  const jobDir = path.join(inputs.jobs, jobName)
-  const summary = JSON.parse(await readFile(path.join(jobDir, 'evaluation-summary.json'), 'utf8'))
-  return {
-    manifest,
-    job: path.relative(inputs.projectRoot, jobDir),
-    summary,
-    doctor,
-    contextPreview: preview,
-    process: { code: processResult.code },
+  try {
+    const processResult = await runProcess(config.harborBin, harborArgs, {
+      cwd: config.projectRoot,
+      timeoutMs: config.timeoutMs,
+      env: {
+        ...process.env,
+        ...(config.pythonPath ? { PYTHONPATH: config.pythonPath } : {}),
+        HSE_MODEL_GATEWAY_URL: lease.endpoint,
+        HSE_MODEL_GATEWAY_TOKEN: lease.token,
+        HSE_MODEL_GATEWAY_PROVIDER: lease.candidateProvider,
+        HSE_MODEL_GATEWAY_INFO: JSON.stringify(lease.modelInfo),
+        HSE_MODEL_GATEWAY_PROTOCOL: lease.protocol,
+      },
+    })
+    const jobDir = path.join(inputs.jobs, jobName)
+    const summary = JSON.parse(await readFile(path.join(jobDir, 'evaluation-summary.json'), 'utf8'))
+    return {
+      manifest,
+      candidateModelBinding: args.candidateModelBinding,
+      job: path.relative(inputs.projectRoot, jobDir),
+      summary,
+      doctor,
+      contextPreview: preview,
+      process: { code: processResult.code },
+    }
+  } finally {
+    await lease.close()
   }
 }
 

package/lib/model-runtime.js

@@ -0,0 +1,216 @@
+import { randomBytes, timingSafeEqual } from 'node:crypto'
+import { once } from 'node:events'
+import { createServer } from 'node:http'
+
+export const MODEL_GATEWAY_PROTOCOL = 'dsh-host-model-gateway/v1'
+export const CANDIDATE_GATEWAY_PROVIDER = 'dsh-host'
+
+function nonBlank(value) {
+  return typeof value === 'string' && value.trim() ? value.trim() : undefined
+}
+
+function sameSecret(expected, actual) {
+  const left = Buffer.from(expected)
+  const right = Buffer.from(actual)
+  return left.length === right.length && timingSafeEqual(left, right)
+}
+
+async function readJsonBody(request, maxBytes) {
+  const chunks = []
+  let size = 0
+  for await (const chunk of request) {
+    size += chunk.length
+    if (size > maxBytes) {
+      throw Object.assign(new Error('model gateway request is too large'), { statusCode: 413 })
+    }
+    chunks.push(chunk)
+  }
+  let value
+  try {
+    value = JSON.parse(Buffer.concat(chunks).toString('utf8'))
+  } catch {
+    throw Object.assign(new Error('model gateway request must be valid JSON'), { statusCode: 400 })
+  }
+  if (value === null || typeof value !== 'object' || Array.isArray(value) || !Array.isArray(value.messages)) {
+    throw Object.assign(new Error('model gateway request requires a messages array'), { statusCode: 400 })
+  }
+  return value
+}
+
+function sendJson(response, statusCode, value) {
+  const body = `${JSON.stringify(value)}\n`
+  response.writeHead(statusCode, {
+    'content-type': 'application/json; charset=utf-8',
+    'content-length': Buffer.byteLength(body),
+    'cache-control': 'no-store',
+  })
+  response.end(body)
+}
+
+function authorized(request, token) {
+  const value = request.headers.authorization
+  return typeof value === 'string' && value.startsWith('Bearer ')
+    && sameSecret(token, value.slice('Bearer '.length))
+}
+
+async function listen(server, host) {
+  server.listen(0, host)
+  await once(server, 'listening')
+  const address = server.address()
+  if (address === null || typeof address === 'string') {
+    throw new Error('model gateway did not bind a TCP port')
+  }
+  return address.port
+}
+
+/**
+ * Freeze the current DSH Agent model per Job, then proxy only that model to an
+ * immutable Candidate. The Candidate receives a short-lived capability, never
+ * the Host provider's credential or route selection.
+ */
+export class CandidateModelRuntime {
+  constructor(ctx, config) {
+    this.ctx = ctx
+    this.config = config
+  }
+
+  async resolve(args = {}) {
+    const explicitProvider = nonBlank(args.candidateProvider)
+    const explicitModel = nonBlank(args.candidateModel)
+    if (Boolean(explicitProvider) !== Boolean(explicitModel)) {
+      throw new Error('candidateProvider and candidateModel must be supplied together')
+    }
+    const configuredProvider = nonBlank(this.config.candidateProvider)
+    const configuredModel = nonBlank(this.config.candidateModel)
+    if (Boolean(configuredProvider) !== Boolean(configuredModel)) {
+      throw new Error('Harbor candidateProvider and candidateModel configuration must be supplied together')
+    }
+
+    const inherited = this.ctx.agentDefaultModel.currentSelection()
+    const provider = explicitProvider ?? configuredProvider ?? inherited.provider
+    const model = explicitModel ?? configuredModel ?? inherited.model
+    const explicitReasoning = nonBlank(args.candidateReasoningEffort)
+    const configuredReasoning = nonBlank(this.config.candidateReasoningEffort)
+    const canInheritReasoning = provider === inherited.provider && model === inherited.model
+    const reasoningEffort = explicitReasoning ?? configuredReasoning
+      ?? (canInheritReasoning ? inherited.reasoningEffort : undefined)
+
+    if (!this.ctx.llm.listProviders().some(item => item.id === provider)) {
+      throw new Error(`Candidate model provider "${provider}" is not registered in DeepSeek Harness`)
+    }
+    const modelInfo = await this.ctx.llm.resolveModelInfo(provider, model)
+    if (provider === 'openai-codex') {
+      const auth = this.ctx.get('codexAuth')
+      if (auth === undefined || typeof auth.status !== 'function') {
+        throw new Error('Candidate model openai-codex requires the dsh-codex-auth service')
+      }
+      const status = await auth.status()
+      if (!status.configured) {
+        throw new Error('Candidate model openai-codex is not signed in; complete GPT Auth in Settings before starting Harbor')
+      }
+    }
+
+    return {
+      provider,
+      model,
+      ...(reasoningEffort === undefined ? {} : { reasoning_effort: String(reasoningEffort) }),
+      transport: 'dsh-host-broker',
+      protocol: MODEL_GATEWAY_PROTOCOL,
+      model_info: modelInfo,
+    }
+  }
+
+  async openLease(binding, scope) {
+    const token = randomBytes(32).toString('base64url')
+    const route = `/harbor-model-gateway/v1/${randomBytes(18).toString('base64url')}`
+    const controllers = new Set()
+    let requestCount = 0
+    const server = createServer(async (request, response) => {
+      if (request.url !== route || !authorized(request, token)) {
+        sendJson(response, 404, { error: 'not found' })
+        return
+      }
+      if (request.method === 'GET') {
+        sendJson(response, 200, {
+          protocol: MODEL_GATEWAY_PROTOCOL,
+          candidate_digest: scope.candidateDigest,
+          job: scope.jobName,
+          binding: {
+            provider: binding.provider,
+            model: binding.model,
+            ...(binding.reasoning_effort === undefined ? {} : { reasoning_effort: binding.reasoning_effort }),
+          },
+        })
+        return
+      }
+      if (request.method !== 'POST') {
+        sendJson(response, 405, { error: 'method not allowed' })
+        return
+      }
+      if (requestCount >= this.config.modelBrokerMaxRequests) {
+        sendJson(response, 429, { error: 'model gateway request budget exhausted' })
+        return
+      }
+      requestCount += 1
+      const controller = new AbortController()
+      controllers.add(controller)
+      response.on('close', () => {
+        if (!response.writableEnded) controller.abort(new Error('Candidate disconnected'))
+      })
+      try {
+        const body = await readJsonBody(request, this.config.modelBrokerMaxRequestBytes)
+        const {
+          provider: _provider,
+          model: _model,
+          reasoningEffort: _reasoningEffort,
+          signal: _signal,
+          ...requestOptions
+        } = body
+        response.writeHead(200, {
+          'content-type': 'application/x-ndjson; charset=utf-8',
+          'cache-control': 'no-store',
+        })
+        const stream = this.ctx.llm.stream({
+          ...requestOptions,
+          provider: binding.provider,
+          model: binding.model,
+          ...(binding.reasoning_effort === undefined ? {} : { reasoningEffort: binding.reasoning_effort }),
+          signal: controller.signal,
+        })
+        for await (const chunk of stream) {
+          if (!response.write(`${JSON.stringify(chunk)}\n`)) await once(response, 'drain')
+        }
+        response.end()
+      } catch (error) {
+        if (!response.headersSent) {
+          const statusCode = Number.isInteger(error?.statusCode) ? error.statusCode : 502
+          const message = error instanceof Error ? error.message : String(error)
+          sendJson(response, statusCode, { error: message })
+        } else if (!response.writableEnded) {
+          response.destroy(error instanceof Error ? error : new Error(String(error)))
+        }
+      } finally {
+        controllers.delete(controller)
+      }
+    })
+
+    const port = await listen(server, this.config.modelBrokerBindHost)
+    const endpoint = `http://${this.config.modelBrokerAdvertisedHost}:${port}${route}`
+    let closed = false
+    return {
+      protocol: MODEL_GATEWAY_PROTOCOL,
+      endpoint,
+      token,
+      candidateProvider: CANDIDATE_GATEWAY_PROVIDER,
+      modelInfo: binding.model_info,
+      async close() {
+        if (closed) return
+        closed = true
+        for (const controller of controllers) controller.abort(new Error('Harbor Job ended'))
+        const close = new Promise((resolve, reject) => server.close(error => error ? reject(error) : resolve()))
+        server.closeAllConnections()
+        await close
+      },
+    }
+  }
+}

package/lib/service.js

@@ -48,9 +48,10 @@ export async function resolveEvaluatorStackPath(config, governance, explicitPath
 
 /** One Host-side boundary shared by Agent tools and the Web dashboard. */
 export class EvolutionService {
-  constructor(config, metadata = {}) {
+  constructor(config, metadata = {}, modelRuntime) {
     this.config = config
     this.metadata = metadata
+    this.modelRuntime = modelRuntime
   }
 
   snapshot(args) {
@@ -61,8 +62,9 @@ export class EvolutionService {
     return initializeProject(this.config, args)
   }
 
-  run(args) {
-    return runEvaluation(this.config, args)
+  async run(args) {
+    const candidateModelBinding = await this.modelRuntime.resolve(args)
+    return runEvaluation(this.config, { ...args, candidateModelBinding }, this.modelRuntime)
   }
 
   result(args) {
@@ -82,16 +84,19 @@ export class EvolutionService {
     return compareCandidates(this.config, args)
   }
 
-  doctor(args) {
-    return runDoctor(this.config, args)
+  async doctor(args) {
+    const candidateModelBinding = await this.modelRuntime.resolve(args)
+    const result = await runDoctor(this.config, args)
+    return { ...result, candidate_model_binding: candidateModelBinding }
   }
 
   validateDataset(args) {
     return validateDataset(this.config, args)
   }
 
-  previewContext(args) {
-    return previewContext(this.config, args)
+  async previewContext(args) {
+    const candidateModelBinding = await this.modelRuntime.resolve(args)
+    return previewContext(this.config, { ...args, candidateModelBinding })
   }
 
   dashboard() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-harbor-evolution",
-  "version": "0.7.0",
+  "version": "0.7.2",
   "description": "DeepSeek Harness plugin and bundled Skill for safely evolving Cordis Candidates with Harbor.",
   "type": "module",
   "main": "index.js",

package/skills/evolve-agent-with-harbor/SKILL.md

@@ -33,7 +33,7 @@ Do not turn an inspection or diagnostic request into Agent mutation or deploymen
 
 Inspect the current workspace before asking questions. Look for Agent entry files, package metadata, curl examples, Dataset instructions, existing Harbor configuration/Jobs, tests, and available Codex or Claude Code commands. Reuse reliable findings and say what was inferred; do not ask the user to transcribe information already present in files.
 
-When no Harbor workspace exists, propose `./harbor-evolution/` under the current working directory as the managed evaluation workspace. Keep imported snapshots and generated evaluation files there. If the installed Plugin is configured to a different `projectRoot`, explain the mismatch and propose the exact configuration change before writing anything.
+When no Harbor workspace exists, propose `./harbor-evolution/` under the current session working directory as the managed evaluation workspace. Agent-facing Harbor Tools derive `projectRoot` from the calling session for every invocation and keep imported snapshots and generated evaluation files inside that request-local root. Treat the Plugin's configured `projectRoot` only as the Web Workbench and non-Agent fallback; do not block initialization merely because it differs from the current session working directory.
 
 Ask only for missing parts of the four-concept intake, using the user's language and short examples:
 

package/skills/evolve-agent-with-harbor/evals/evals.json

@@ -33,6 +33,17 @@
         "The response maps the supplied paths and curl into the four-concept confirmation card.",
         "The response does not run initialization or evaluation before confirmation."
       ]
+    },
+    {
+      "id": 4,
+      "prompt": "当前 Session 工作目录是 /Users/mac/Documents/Harness，但 Harbor Plugin 配置里显示的 projectRoot 是 /Users/mac/Library/Application Support/XiaoHui Harness/workspace。请在当前项目下初始化 ./harbor-evolution。",
+      "expected_output": "把当前 Session 工作目录作为 Agent Tool 的项目根目录，继续准备 /Users/mac/Documents/Harness/harbor-evolution 的初始化确认卡；说明配置值只供 Web Workbench 或非 Agent 场景回退使用，不要求修改配置，也不因路径不同而拒绝初始化。",
+      "files": [],
+      "assertions": [
+        "The response treats the calling session working directory as the Agent Tool project root.",
+        "The response does not block initialization or require a projectRoot configuration change because the fallback differs.",
+        "The proposed managed workspace stays under /Users/mac/Documents/Harness."
+      ]
     }
   ]
 }

package/skills/evolve-agent-with-harbor/references/initialization.md

@@ -13,7 +13,7 @@ Keep onboarding anchored on four visible concepts:
 | 评测器（评测标准） (Evaluator) | 怎样算好？ | evaluator curl/path, or natural-language criteria | Evaluator, Rubric, Judge identity, Evaluation Contract |
 | 优化器 (Optimizer) | 谁根据结果改进？ | current Agent, Codex, Claude Code, or local command | Optimizer identity, mutation surface, rollback workflow |
 
-Inspect first and prefill everything reliable. Ask only about missing rows. Use `./harbor-evolution/` as the proposed managed workspace when no project exists, but do not write outside the Plugin's configured `projectRoot`; surface a configuration mismatch before initialization.
+Inspect first and prefill everything reliable. Ask only about missing rows. Use `./harbor-evolution/` as the proposed managed workspace when no project exists. Agent-facing Harbor Tools resolve every path inside the calling session's working directory, so a different configured `projectRoot` is only a Web Workbench or non-Agent fallback and must not block initialization.
 
 Before any write, show the four rows plus inferred workspace, diagnostic/promotion scope, and deferred capabilities. The user may start initialization, modify the card, or open advanced configuration.