feat: improve agent model selection and remote source analysis; bump to 1.2.23

scripts/test-agent-code-navigation.cjs

@@ -188,7 +188,8 @@ test('a new question cancels pending navigation without leaving its old state st
 })
 
 test('restored interrupted navigation becomes retryable without reopening any file', () => {
-  const { recoverInterruptedAgentMessages } = compile(fs.readFileSync(require.resolve('../src/renderer/src/features/workspace/agentContext.ts'), 'utf8'))
+  const evidence = compile(fs.readFileSync(require.resolve('../src/renderer/src/features/workspace/agentEvidence.ts'), 'utf8'))
+  const { recoverInterruptedAgentMessages } = compile(fs.readFileSync(require.resolve('../src/renderer/src/features/workspace/agentContext.ts'), 'utf8'), {}, name => name === './agentEvidence' ? evidence : require(name))
   const message = { id: 'answer', role: 'assistant', codeReferenceStates: { pending: { status: 'opening' }, approved: { status: 'opened' }, declined: { status: 'cancelled' } } }
   const restored = recoverInterruptedAgentMessages([message])[0]
   assert.equal(restored.codeReferenceStates.pending.status, 'error')

scripts/test-agent-context.cjs

@@ -5,9 +5,13 @@ const vm = require('node:vm')
 const ts = require('typescript')
 
 const output = {}
+const evidenceApi = {}
+vm.runInNewContext(ts.transpileModule(fs.readFileSync(require.resolve('../src/renderer/src/features/workspace/agentEvidence.ts'), 'utf8'), {
+  compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 }
+}).outputText, { exports: evidenceApi })
 vm.runInNewContext(ts.transpileModule(fs.readFileSync(require.resolve('../src/renderer/src/features/workspace/agentContext.ts'), 'utf8'), {
   compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 }
-}).outputText, { exports: output, DOMException })
+}).outputText, { exports: output, DOMException, require: name => { assert.equal(name, './agentEvidence'); return evidenceApi } })
 const { resolveAgentContext } = output
 const plain = value => JSON.parse(JSON.stringify(value))
 const moduleInfo = (name, files = []) => ({ name, state: 'stopped', files })

scripts/test-agent-evidence.cjs

@@ -0,0 +1,143 @@
+const { test } = require('node:test')
+const assert = require('node:assert/strict')
+const fs = require('node:fs')
+const ts = require('typescript')
+require.extensions['.ts'] = (module, filename) => module._compile(ts.transpileModule(fs.readFileSync(filename, 'utf8'), {
+  compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 }
+}).outputText, filename)
+const { compactAgentEvidence, missingAgentRead, readFileEvidence } = require('../src/renderer/src/features/workspace/agentEvidence.ts')
+const { resolveAgentContext } = require('../src/renderer/src/features/workspace/agentContext.ts')
+const file = (startLine, endLine, extra = {}, result = {}) => ({
+  id: `read-${startLine}-${endLine}`, name: 'files.read', moduleName: 'Control', target: 'ssh:jetson', status: 'ok', observedAt: '2026-10-20T00:00:00.000Z', truncated: true,
+  data: JSON.stringify({ path: 'config/car.yaml', exists: true, hash: 'a'.repeat(64), content: Array.from({ length: endLine - startLine + 1 }, (_, i) => `line${startLine + i}`).join('\n'),
+    startLine, endLine, totalLines: 100, complete: false, contentTruncated: false, ...extra }), ...result
+})
+const read = (startLine, lineCount, path = 'config/car.yaml') => ({ id: 'read', name: 'files.read', moduleName: 'Control', args: { path, ...(startLine === undefined ? {} : { startLine }), ...(lineCount === undefined ? {} : { lineCount }) } })
+const answer = toolRequests => ({ provider: 'test', model: 'test', plan: { summary: 'result', explanation: 'verified code', toolRequests, changes: [], commands: [], actionPlan: [], createModule: null } })
+
+test('overlapping and adjacent ranges merge without promoting partial evidence to editable full files', () => {
+  const results = compactAgentEvidence([file(1, 10), file(8, 15), file(16, 20)])
+  assert.equal(results.length, 1)
+  const data = readFileEvidence(results[0])
+  assert.equal(data.startLine, 1)
+  assert.equal(data.endLine, 20)
+  assert.equal(data.content.split('\n').length, 20)
+  assert.equal(data.complete, false)
+  assert.equal(results[0].truncated, true)
+  assert.equal(missingAgentRead(read(3, 16), results), undefined)
+  assert.deepEqual(missingAgentRead(read(), results), read())
+})
+
+test('queries only the first missing range and never joins disjoint or conflicting content', () => {
+  const results = compactAgentEvidence([file(1, 5), file(10, 15)])
+  assert.equal(results.length, 2)
+  assert.deepEqual(missingAgentRead(read(3, 15), results).args, { path: 'config/car.yaml', startLine: 6, lineCount: 4 })
+  assert.equal(compactAgentEvidence([file(1, 10), file(8, 15, { content: 'different\ncontent' })]).length, 2)
+})
+
+test('host boundaries and file revisions cannot be combined or used to fill each other’s gaps', () => {
+  const changed = compactAgentEvidence([file(1, 10), file(11, 20, { hash: 'b'.repeat(64) })])
+  assert.equal(changed.length, 1)
+  assert.equal(missingAgentRead(read(1, 20), changed).args.startLine, 1)
+  const hosts = compactAgentEvidence([file(1, 10, {}, { target: 'local-host' }), file(11, 20)])
+  assert.equal(hosts.length, 2)
+  assert.equal(missingAgentRead(read(1, 20), hosts).args.startLine, 1)
+})
+
+test('full and missing observations are reused but partial character fragments are never coverage', () => {
+  const full = file(1, 10, { complete: true }, { truncated: false })
+  assert.equal(missingAgentRead(read(5, 100), [full]), undefined)
+  assert.equal(compactAgentEvidence([full, file(5, 8)]).length, 1)
+  const missing = file(1, 1, { exists: false, content: '', hash: null, complete: true }, { truncated: false })
+  assert.equal(missingAgentRead(read(), [missing]), undefined)
+  const cut = file(1, 2, { content: 'whole\ncut', endLine: 1, contentTruncated: true })
+  assert.equal(missingAgentRead(read(2, 1), [cut]).args.startLine, 2)
+  const legacy = file(1, 2, { endLine: undefined, contentTruncated: undefined })
+  assert.equal(missingAgentRead(read(2, 1), [legacy]).args.startLine, 2)
+})
+
+test('malformed or oversized evidence never becomes reusable complete coverage', () => {
+  assert.equal(readFileEvidence(file(1, 10, { hash: 'not-a-hash' })), undefined)
+  assert.equal(readFileEvidence(file(1, 10, { endLine: 999 })), undefined)
+  const large = compactAgentEvidence([file(1, 1, { content: 'a'.repeat(30_000) }), file(2, 2, { content: 'b'.repeat(30_000) })])
+  assert.equal(large.length, 2)
+})
+
+test('overlap requests execute only missing lines and finish once the requested range is cached', async () => {
+  const executions = []
+  let calls = 0
+  await resolveAgentContext({
+    initialContext: { modules: [], runtimeLogs: [] }, signal: new AbortController().signal,
+    executeTool: async tool => { executions.push(tool.args); return file(tool.args.startLine, tool.args.startLine + tool.args.lineCount - 1) },
+    requestPlan: async (context, final) => {
+      calls++
+      if (final) {
+        assert.equal(context.toolResults.length, 1)
+        assert.equal(JSON.parse(context.toolResults[0].data).endLine, 15)
+        return answer([])
+      }
+      return answer([[read(1, 10)], [read(5, 11)], [read(4, 10)]][calls - 1])
+    }
+  })
+  assert.deepEqual(executions, [read(1, 10).args, read(11, 5).args])
+  assert.equal(calls, 4)
+})
+
+test('source evidence survives many later searches and omissions are reported within DTO limits', async () => {
+  const searchResults = Array.from({ length: 15 }, (_, i) => ({ ...file(1, 1), id: `search-${i}`, name: 'files.search', data: JSON.stringify({ query: `speed${i}`, matches: [] }) }))
+  await resolveAgentContext({
+    initialContext: { modules: [], runtimeLogs: [], toolResults: [file(1, 10), ...searchResults] }, signal: new AbortController().signal,
+    requestPlan: async context => {
+      assert.equal(context.toolResults.length, 12)
+      assert.equal(context.toolResults[0].name, 'files.read')
+      assert.match(context.contextNotes[0], /4개/)
+      assert.ok(context.contextNotes.length <= 12)
+      assert.ok(context.contextNotes.every(note => note.length <= 500))
+      return answer([])
+    }
+  })
+})
+
+test('a cached file omitted by budgets is restored when the model requests it again', async () => {
+  let calls = 0
+  const results = Array.from({ length: 13 }, (_, i) => file(1, 10, { path: `file${i}.yaml` }))
+  await resolveAgentContext({
+    initialContext: { modules: [], runtimeLogs: [], toolResults: results }, signal: new AbortController().signal,
+    executeTool: async () => { throw Error('cached file must not be queried again') },
+    requestPlan: async (context, final) => {
+      calls++
+      if (!final) return answer([read(1, 5, 'file0.yaml')])
+      assert.ok(context.toolResults.some(result => JSON.parse(result.data).path === 'file0.yaml'))
+      return answer([])
+    }
+  })
+  assert.equal(calls, 2)
+})
+
+test('finalization retains verified code locations while stripping all proposed mutations', async () => {
+  const reference = { id: 'code-1', moduleName: 'Control', path: 'config/car.yaml', startLine: 1, endLine: 3, reason: 'verified', expectedHash: 'a'.repeat(64), snippet: 'line1' }
+  const result = await resolveAgentContext({
+    initialContext: { modules: [], runtimeLogs: [], toolResults: [file(1, 10)] }, signal: new AbortController().signal,
+    executeTool: async () => { throw Error('already cached') },
+    requestPlan: async (_, final) => ({ ...answer([read(1, 5)]), plan: { ...answer([read(1, 5)]).plan, ...(final ? { changes: [{ path: 'unsafe' }], commands: [{ command: 'unsafe' }] } : { codeReferences: [reference] }) } })
+  })
+  assert.equal(result.plan.codeReferences.length, 1)
+  assert.match(result.plan.explanation, /verified code/)
+  assert.deepEqual(result.plan.changes, [])
+  assert.deepEqual(result.plan.commands, [])
+})
+
+test('recovery never resurrects code locations after a different file revision was observed', async () => {
+  let calls = 0
+  const reference = { id: 'code-1', moduleName: 'Control', path: 'config/car.yaml', startLine: 1, endLine: 3, reason: 'verified', expectedHash: 'a'.repeat(64), snippet: 'line1' }
+  const result = await resolveAgentContext({
+    initialContext: { modules: [], runtimeLogs: [], toolResults: [file(1, 10)] }, signal: new AbortController().signal,
+    executeTool: async () => file(11, 20, { hash: 'b'.repeat(64) }),
+    requestPlan: async (_, final) => {
+      calls++
+      return !final && calls === 1 ? { ...answer([read(11, 10)]), plan: { ...answer([read(11, 10)]).plan, codeReferences: [reference] } } : answer([read(11, 10)])
+    }
+  })
+  assert.deepEqual(result.plan.codeReferences, [])
+  assert.match(result.plan.summary, /확정하지 못했습니다/)
+})

scripts/test-agent-model-selection.cjs

@@ -0,0 +1,63 @@
+const { test } = require('node:test')
+const assert = require('node:assert/strict')
+const fs = require('node:fs')
+const vm = require('node:vm')
+const ts = require('typescript')
+const React = require('react')
+
+function compile(path, overrides = {}) {
+  const exports = {}
+  const source = fs.readFileSync(require.resolve(path), 'utf8')
+  vm.runInNewContext(ts.transpileModule(source, { compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022, jsx: ts.JsxEmit.ReactJSX } }).outputText,
+    { exports, require: name => overrides[name] ?? require(name) })
+  return exports
+}
+const models = compile('../src/renderer/src/features/workspace/agentModels.ts')
+const options = [{ provider: 'OPENAI', model: 'gpt-6.1-sol', imagesEnabled: false }, { provider: 'QWEN', model: 'qwen3.8-flash', imagesEnabled: true }]
+const plain = value => JSON.parse(JSON.stringify(value))
+
+test('normalizes enabled models, validates IDs and preserves old single-model servers', () => {
+  const status = models.normalizeAgentStatus({ enabled: true, models: [options[1], options[0], options[0], { provider: 'FORGED', model: 'bad' }, { provider: 'GEMINI', model: '' }] })
+  assert.deepEqual(plain(status.models), options)
+  assert.equal(status.selectionSupported, true)
+  assert.deepEqual(plain(models.normalizeAgentStatus({ enabled: true, ...options[1] }).models), [options[1]])
+  assert.equal(models.normalizeAgentStatus({ enabled: true, ...options[1] }).selectionSupported, false)
+  assert.equal(models.normalizeAgentStatus({ enabled: false, models: options }).models.length, 0)
+  assert.equal(models.normalizeAgentStatus({ enabled: true, models: [] }).enabled, false)
+})
+
+test('selects the saved provider only while it is available, and never invents one', () => {
+  assert.equal(models.selectedAgentModel(options, 'QWEN'), options[1])
+  assert.equal(models.selectedAgentModel(options, 'ANTHROPIC'), options[0])
+  assert.equal(models.selectedAgentModel([options[0]], 'QWEN'), options[0])
+  assert.equal(models.selectedAgentModel([], 'QWEN'), null)
+})
+
+function elements(root, predicate) {
+  if (!React.isValidElement(root)) return []
+  return [...(predicate(root) ? [root] : []), ...React.Children.toArray(root.props.children).flatMap(child => elements(child, predicate))]
+}
+const { AgentModelSelector } = compile('../src/renderer/src/components/AgentModelSelector.tsx', {
+  '../i18n': { t: value => value }, '../features/workspace/agentModels': models,
+})
+
+for (const dark of [true, false]) test(`model control lists only allowed providers and follows the theme (${dark})`, () => {
+  let selected
+  const tree = AgentModelSelector({ models: options, provider: 'QWEN', dark, disabled: false, onChange: value => { selected = value } })
+  const select = elements(tree, node => node.type === 'select')[0]
+  assert.equal(select.props.value, 'QWEN')
+  assert.equal(select.props.style.colorScheme, dark ? 'dark' : 'light')
+  assert.deepEqual(elements(select, node => node.type === 'option').map(node => node.props.value), ['OPENAI', 'QWEN'])
+  select.props.onChange({ target: { value: 'OPENAI' } })
+  assert.equal(selected, 'OPENAI')
+  assert.match(select.props.className, /truncate/)
+  assert.ok(elements(AgentModelSelector({ models: options, provider: 'QWEN', dark, disabled: true, onChange() {} }), node => node.type === 'select')[0].props.disabled)
+  const empty = elements(AgentModelSelector({ models: [], provider: null, dark, disabled: false, onChange() {} }), node => node.type === 'select')[0]
+  assert.ok(empty.props.disabled)
+  assert.equal(elements(empty, node => node.type === 'option')[0].props.children, '사용 가능한 모델 없음')
+})
+
+test('A-Copilot has a single managed label', () => {
+  assert.equal(models.agentModelLabel({ provider: 'A_COPILOT', model: 'A-Copilot', imagesEnabled: false }), 'A-Copilot')
+  assert.equal(models.agentModelLabel(options[0]), 'OpenAI · gpt-6.1-sol')
+})

scripts/test-agent-progress.cjs

@@ -11,7 +11,10 @@ function compile(source, globals = {}) {
   }).outputText, { exports, DOMException, Error, ...globals })
   return exports
 }
-const context = compile(fs.readFileSync(require.resolve('../src/renderer/src/features/workspace/agentContext.ts'), 'utf8'))
+const evidenceApi = compile(fs.readFileSync(require.resolve('../src/renderer/src/features/workspace/agentEvidence.ts'), 'utf8'))
+const context = compile(fs.readFileSync(require.resolve('../src/renderer/src/features/workspace/agentContext.ts'), 'utf8'), {
+  require: name => { assert.equal(name, './agentEvidence'); return evidenceApi }
+})
 const source = ts.createSourceFile('useAiAgent.ts', fs.readFileSync(require.resolve('../src/renderer/src/features/workspace/useAiAgent.ts'), 'utf8'), ts.ScriptTarget.Latest, true)
 const hook = source.statements.find(node => ts.isFunctionDeclaration(node) && node.name?.text === 'useAiAgent')
 const functions = hook.body.statements.filter(node => ts.isVariableStatement(node) && ['requestPlan', 'stop'].includes(node.declarationList.declarations[0].name.getText(source)))
@@ -27,11 +30,13 @@ function harness(requestApi) {
   class Clock extends Date { static now() { return now } }
   const state = { pending: false, activity: '', steps: [], messages: [], saved: [], notices: 0, requestStartedAt: null }
   const messageStateRef = { current: { session } }
+  const selectedModel = { provider: 'QWEN', model: 'fixture', imagesEnabled: true }
   const api = compile(functions.map(node => `export ${node.getText(source)}`).join('\n'), {
-    ...context, session, messageStateRef, AbortController,
+    ...context, session, messageStateRef, AbortController, FormData,
     Date: Clock,
-    courseId: 'course', weekNumber: 3, pending: false, historyLoading: false,
-    status: { enabled: true }, abortControllerRef: { current: null },
+    courseId: 'course', weekNumber: 3, pending: false, historyLoading: false, statusLoading: false,
+    selectedModel,
+    status: { enabled: true, selectionSupported: true }, abortControllerRef: { current: null },
     setPending: value => { state.pending = value },
     setRequestStartedAt: value => { state.requestStartedAt = value },
     setActivity: value => { state.activity = value },
@@ -39,7 +44,7 @@ function harness(requestApi) {
     updateMessages: update => { state.messages = update(state.messages); state.saved.push(plain(state.messages)) },
     onResponseRef: { current: () => { state.notices++ } }, requestApi
   })
-  return { ...api, state, messageStateRef, advance: ms => { now += ms } }
+  return { ...api, state, selectedModel, messageStateRef, advance: ms => { now += ms } }
 }
 
 test('publishes completed stages immediately without persisting progress or adding model calls', async () => {
@@ -76,6 +81,58 @@ test('publishes completed stages immediately without persisting progress or addi
   assert.equal(h.state.notices, 1)
 })
 
+test('image uploads and every lookup round retain the original provider without uploading the image twice', async () => {
+  const bodies = []
+  let uploads = 0
+  const h = harness(async (path, request) => {
+    if (path.endsWith('/attachments/images')) {
+      uploads++
+      assert.equal(request.body.get('provider'), 'QWEN')
+      assert.equal(request.body.get('courseId'), 'course')
+      assert.equal(request.body.get('week'), '3')
+      assert.equal(request.body.get('file').name, 'screen.png')
+      return { token: 'image-reference', name: 'screen.png', url: 'https://images.test/screen.png' }
+    }
+    bodies.push(JSON.parse(request.body))
+    h.selectedModel.provider = 'OPENAI'
+    return bodies.length === 1
+      ? { ...response(), plan: { ...response().plan, requestedModules: ['Control'] } }
+      : response()
+  })
+  await h.requestPlan('이미지 확인', [{ name: 'Control', files: [] }], [], {
+    attachments: [{ kind: 'image', name: 'screen.png', file: new Blob(['fixture'], { type: 'image/png' }) }],
+    loadRequestedContext: async () => ({ modules: [{ name: 'Control', files: [{ path: 'config/control.yaml', content: 'speed: 0.3' }] }], runtimeLogs: [] })
+  })
+  assert.equal(uploads, 1)
+  assert.equal(bodies.length, 2)
+  assert.ok(bodies.every(body => body.provider === 'QWEN'))
+  assert.ok(bodies.every(body => body.imageTokens[0] === 'image-reference'))
+  assert.equal(h.state.messages.at(-1).model, 'fixture')
+})
+
+test('remote target and observed source ranges reach each provider request including finalization', async () => {
+  const bodies = []
+  const tool = { id: 'read', name: 'files.read', moduleName: 'Control', args: { path: 'config/car.yaml', startLine: 20, lineCount: 1 } }
+  const h = harness(async (_, request) => {
+    bodies.push(JSON.parse(request.body))
+    return bodies.length < 3 ? response([tool]) : response()
+  })
+  await h.requestPlan('속도 제한 코드 위치', [{ name: 'Control', state: 'running', parameters: ['sim_mode:=false'], files: [] }], [], {
+    environment: 'remote', workspaceTarget: 'ssh:100.64.0.10',
+    executeTool: async input => result({ id: input.id, moduleName: 'Control', target: 'ssh:100.64.0.10', truncated: true,
+      data: JSON.stringify({ path: 'config/car.yaml', exists: true, hash: 'a'.repeat(64), complete: false, content: 'max_speed: 0.4', startLine: 20, endLine: 20, contentTruncated: false, totalLines: 100 }) })
+  })
+  assert.equal(bodies.length, 3)
+  for (const body of bodies) {
+    assert.equal(body.environment, 'remote')
+    assert.equal(body.workspaceTarget, 'ssh:100.64.0.10')
+    assert.deepEqual(body.modules[0].parameters, ['sim_mode:=false'])
+  }
+  assert.equal(JSON.parse(bodies[1].toolResults[0].data).content, 'max_speed: 0.4')
+  assert.equal(JSON.parse(bodies[2].toolResults[0].data).endLine, 20)
+  assert.match(bodies[2].request, /자료 조회는 종료되었습니다/)
+})
+
 test('errors replace temporary progress with the existing error reply', async () => {
   let calls = 0
   const h = harness(async () => {

scripts/test-agent-request-payload.cjs

@@ -4,9 +4,13 @@ const fs = require('node:fs')
 const vm = require('node:vm')
 const ts = require('typescript')
 const contextApi = {}
+const evidenceApi = {}
+vm.runInNewContext(ts.transpileModule(fs.readFileSync(require.resolve('../src/renderer/src/features/workspace/agentEvidence.ts'), 'utf8'), {
+  compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 }
+}).outputText, { exports: evidenceApi })
 vm.runInNewContext(ts.transpileModule(fs.readFileSync(require.resolve('../src/renderer/src/features/workspace/agentContext.ts'), 'utf8'), {
   compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 }
-}).outputText, { exports: contextApi, DOMException })
+}).outputText, { exports: contextApi, DOMException, require: name => { assert.equal(name, './agentEvidence'); return evidenceApi } })
 
 const source = ts.createSourceFile('useAiAgent.ts', fs.readFileSync(require.resolve('../src/renderer/src/features/workspace/useAiAgent.ts'), 'utf8'), ts.ScriptTarget.Latest, true)
 let payloadExpression
@@ -33,10 +37,11 @@ test('user messages preserve only typed text while attachments remain separate m
   }
 })
 
-function serialize(attachments, finalize = false, request = '설정 위치 알려줘', imageTokens = []) {
+function serialize(attachments, finalize = false, request = '설정 위치 알려줘', imageTokens = [], provider = 'QWEN') {
   return JSON.parse(vm.runInNewContext(payloadExpression, {
     courseId: 'course-1', weekNumber: 3, request, options: { attachments }, finalize,
     textAttachments: attachments ?? [], imageTokens,
+    selection: provider ? { provider } : {},
     agentPlanRequestText: contextApi.agentPlanRequestText,
     context: { modules: [{ name: 'Control', files: [] }], runtimeLogs: [] }
   }))
@@ -70,7 +75,7 @@ test('finalization instruction reaches the API without sending unsupported DTO f
   assert.match(body.request, /설정 위치 알려줘/)
   assert.match(body.request, /최종 답변/)
   assert.equal(Object.hasOwn(body, 'finalize'), false)
-  assert.deepEqual(Object.keys(body).sort(), ['courseId', 'modules', 'request', 'runtimeLogs', 'week'])
+  assert.deepEqual(Object.keys(body).sort(), ['courseId', 'modules', 'provider', 'request', 'runtimeLogs', 'week'])
 })
 
 test('finalization keeps the request within the backend 4000-character limit', () => {
@@ -78,3 +83,14 @@ test('finalization keeps the request within the backend 4000-character limit', (
   assert.equal(body.request.length, 4000)
   assert.match(body.request, /원래 학생 질문/)
 })
+
+test('sends only a provider selection rather than student-supplied models or keys', () => {
+  for (const finalize of [false, true]) {
+    const body = serialize(undefined, finalize, '확인', [], 'OPENAI')
+    assert.equal(body.provider, 'OPENAI')
+    assert.equal(Object.hasOwn(body, 'model'), false)
+    assert.equal(Object.hasOwn(body, 'apiKey'), false)
+    assert.equal(Object.hasOwn(body, 'endpointUrl'), false)
+  }
+  assert.equal(Object.hasOwn(serialize(undefined, false, '확인', [], null), 'provider'), false)
+})

scripts/test-agent-tools.cjs

@@ -63,15 +63,30 @@ for (const backend of ['local', 'remote']) {
     const full = await read(root, request('files.read', { path: 'config/sensor.yaml' }))
     assert.equal(full.data.hash, agentFileHash(await fs.readFile(path.join(root, 'config/sensor.yaml'), 'utf8')))
     assert.equal(full.data.complete, true)
+    const rangedFull = await read(root, request('files.read', { path: 'config/sensor.yaml', startLine: 1, lineCount: 200 }))
+    assert.equal(rangedFull.data.complete, true)
+    assert.equal(rangedFull.truncated, false)
+    assert.equal(rangedFull.data.endLine, 3)
+    assert.equal(rangedFull.data.contentTruncated, false)
     const partial = await read(root, request('files.read', { path: 'config/sensor.yaml', startLine: 2, lineCount: 1 }))
     assert.equal(partial.data.content, '조향: ackermann')
     assert.equal(partial.data.complete, false)
     assert.equal(partial.truncated, true)
+    assert.equal(partial.data.endLine, 2)
+    assert.equal(partial.data.contentTruncated, false)
     const missing = await read(root, request('files.read', { path: 'config/new.yaml' }))
     assert.equal(missing.data.exists, false)
     assert.equal(missing.data.hash, null)
     await assert.rejects(read(root, request('files.read', { path: 'missing/new.yaml' })))
   })
+  test(`${backend}: character truncation never advertises a cut line as fully observed`, async t => {
+    const root = await fixture(t)
+    await fs.writeFile(path.join(root, 'config/long.yaml'), `first: true\n${'x'.repeat(40_000)}\nlast: true`)
+    const readout = await read(root, request('files.read', { path: 'config/long.yaml', startLine: 1, lineCount: 3 }))
+    assert.equal(readout.data.complete, false)
+    assert.equal(readout.data.contentTruncated, true)
+    assert.equal(readout.data.endLine, 1)
+  })
   test(`${backend}: a scoped search does not consume its budget in unrelated source trees`, async t => {
     const root = await fixture(t)
     await fs.mkdir(path.join(root, 'code'))

scripts/test-agent-workspace-routing.cjs

@@ -0,0 +1,68 @@
+const { test } = require('node:test')
+const assert = require('node:assert/strict')
+const fs = require('node:fs')
+const ts = require('typescript')
+const vm = require('node:vm')
+const app = ts.createSourceFile('App.tsx', fs.readFileSync(require.resolve('../src/renderer/src/App.tsx'), 'utf8'), ts.ScriptTarget.Latest, true, ts.ScriptKind.TSX)
+const declarations = new Map()
+function visit(node) {
+  if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name)) declarations.set(node.name.text, node.initializer?.getText(app))
+  ts.forEachChild(node, visit)
+}
+visit(app)
+const plain = value => JSON.parse(JSON.stringify(value))
+
+function harness(remoteWorkspace) {
+  const executions = []
+  const calls = []
+  const errors = []
+  const target = { host: '100.64.0.10', user: 'fixture', workspaceRoot: '/fixture/workspace' }
+  const live = [{ name: 'NAV2-MKMini', folderName: 'vehicle', state: 'running', parameters: ['sim_mode:=false', 'robot:=mkmini'] }]
+  const readTool = backend => async (...args) => { executions.push({ backend, args: plain(args) }); return { status: 'ok', data: '{"content":"remote source"}' } }
+  const exports = {}
+  const globals = {
+    exports, remoteWorkspace, availableModules: [{ ...live[0], state: 'stopped', parameters: ['sim_mode:=true'] }],
+    clonePathPreview: '/local/workspace', runtimeModules: [], agentActionControllerRef: { current: null }, agentApplying: false,
+    getRemoteWorkspaceTarget: () => target, applyModuleParameterOverrides: modules => modules,
+    validateAgentTool: request => request, AGENT_PRACTICE_PROFILES: [],
+    window: {
+      remoteWorkspace: { modules: { list: async () => ({ modules: live }) }, agent: { readTool: readTool('remote') } },
+      localWorkspace: { modules: { list: async () => ({ modules: live }) }, agent: { readTool: readTool('local') } }
+    },
+    requestAgentPlan: async (...args) => { calls.push(args) },
+    onTitlebarNotice: (...args) => { errors.push(args) }, console: { error: () => {} },
+    loadAgentRequestedContext: async () => ({ modules: [], runtimeLogs: [] })
+  }
+  const names = ['collectAgentWorkspace', 'readAgentModules', 'executeWorkspaceAgentTool', 'submitAgentRequest']
+  vm.runInNewContext(ts.transpileModule(names.map(name => `const ${name} = ${declarations.get(name)}; exports.${name} = ${name}`).join('\n'), {
+    compilerOptions: { module: ts.ModuleKind.CommonJS, target: ts.ScriptTarget.ES2022 }
+  }).outputText, globals)
+  return { ...exports, executions, calls, errors }
+}
+
+for (const remote of [false, true]) {
+  test(`${remote ? 'remote' : 'local'}: a new question refreshes state and start settings before sending context`, async () => {
+    const h = harness(remote)
+    await h.submitAgentRequest('최대 속도 제한 코드 위치')
+    assert.deepEqual(h.errors, [])
+    assert.equal(h.calls.length, 1)
+    const [, modules, , options] = h.calls[0]
+    assert.equal(modules[0].state, 'running')
+    assert.deepEqual(plain(modules[0].parameters), ['sim_mode:=false', 'robot:=mkmini'])
+    assert.deepEqual(plain(modules[0].files), [])
+    assert.equal(options.environment, remote ? 'remote' : 'local')
+    assert.equal(options.workspaceTarget, remote ? 'ssh:100.64.0.10' : 'local-host')
+  })
+
+  test(`${remote ? 'remote' : 'local'}: source reads use only the connected workspace transport and module folder`, async () => {
+    const h = harness(remote)
+    const tool = { id: 'read-1', name: 'files.read', moduleName: 'NAV2-MKMini', args: { path: 'src/profiles.py', startLine: 10, lineCount: 20 } }
+    await h.executeWorkspaceAgentTool(tool)
+    assert.equal(h.executions.length, 1)
+    assert.equal(h.executions[0].backend, remote ? 'remote' : 'local')
+    const args = h.executions[0].args
+    assert.deepEqual(args[remote ? 1 : 0], tool)
+    assert.equal(args[2], 'vehicle')
+    assert.equal(remote ? args[0].host : args[1], remote ? '100.64.0.10' : '/local/workspace')
+  })
+}

scripts/test-chat-clear-confirmation.cjs

@@ -42,6 +42,7 @@ function setup(overrides = {}, browser = {}) {
     '../../components/AgentProgressBubble': {},
     '../../components/AgentWorkDuration': {},
     '../../components/AgentCodeReferences': {},
+    '../../components/AgentModelSelector': { AgentModelSelector: () => null },
     'react-dom': { createPortal: child => child },
     react: {
       ...React,