nolo-cli 0.8.0 → 0.9.1

package/chunk-YBWOP46I.js

@@ -0,0 +1,3272 @@
+import {
+  applyChatCompletionDelta,
+  finalizeAccumulatedToolCalls,
+  flushChatCompletionStream,
+  readSseFrames,
+  throwIfChatCompletionStreamFailed,
+  toOpenAiCompatibleMessages
+} from "./chunk-5KLGBAAR.js";
+import {
+  parseToolArgumentsJson
+} from "./chunk-XS466O7S.js";
+import {
+  createThinkParserState,
+  extractThinkContent
+} from "./chunk-OPZYGHUC.js";
+import {
+  buildProviderAuthHeaders,
+  buildProviderExecutionPlan
+} from "./chunk-JRKKFRAV.js";
+import {
+  canonicalizeToolName,
+  createGlob,
+  resolveExecutableOnPath
+} from "./chunk-AUQ747NZ.js";
+import {
+  toErrorMessage
+} from "./chunk-HNMXYYJR.js";
+import {
+  asRecordOrEmpty
+} from "./chunk-KX6YBIHG.js";
+import {
+  dialogMessageKey
+} from "./chunk-SH2CFQOH.js";
+import {
+  asTrimmedNonEmptyStringArray
+} from "./chunk-I42VC5KR.js";
+import {
+  asOptionalFiniteNumber
+} from "./chunk-WWC7I6TA.js";
+import {
+  asTrimmedLowercaseString
+} from "./chunk-QSJ3HFEF.js";
+import {
+  asTrimmedString
+} from "./chunk-3EUW3WEO.js";
+import {
+  asOptionalPositiveFiniteNumber
+} from "./chunk-U6VC4MU4.js";
+import {
+  normalizeServerOrigin
+} from "./chunk-CF7PE763.js";
+import {
+  asOptionalTrimmedString
+} from "./chunk-G3SUCT4W.js";
+import {
+  isRecord
+} from "./chunk-KUG52IAP.js";
+
+// packages/agent-runtime/kimiUserAgent.ts
+var KIMI_CODE_CLI_VERSION = "0.29.2";
+var KIMI_CODE_USER_AGENT = `kimi-code-cli/${KIMI_CODE_CLI_VERSION} (nolo)`;
+function isKimiEndpoint(url) {
+  return url.includes("api.kimi.com");
+}
+function kimiIdentityHeaders(url) {
+  return isKimiEndpoint(url) ? { "User-Agent": KIMI_CODE_USER_AGENT } : {};
+}
+
+// packages/agent-runtime/sseDataLine.ts
+function parseSseDataLineJson(line) {
+  const trimmed = line.trim();
+  if (!trimmed.startsWith("data:")) return null;
+  const payload = trimmed.slice(5).trim();
+  if (!payload || payload === "[DONE]") return null;
+  try {
+    return JSON.parse(payload);
+  } catch {
+    return null;
+  }
+}
+
+// packages/agent-runtime/openAiCompatibleProvider.ts
+function buildOpenAiCompatibleChatCompletionRequest(args) {
+  const body = {
+    model: args.providerConfig.model,
+    messages: toOpenAiCompatibleMessages(args.messages),
+    stream: args.stream ?? false,
+    ...args.providerConfig.requestOptions,
+    ...args.tools && args.tools.length > 0 ? { tools: args.tools } : {},
+    ...args.stream ? { stream_options: { include_usage: true } } : {}
+  };
+  const endpoint = args.providerConfig.endpoint;
+  const headers = {
+    "Content-Type": "application/json",
+    ...buildProviderAuthHeaders({
+      endpoint,
+      apiKey: args.providerConfig.apiKey,
+      apiKeyHeader: args.providerConfig.apiKeyHeader
+    }),
+    ...kimiIdentityHeaders(endpoint)
+  };
+  return {
+    url: endpoint,
+    init: {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body)
+    }
+  };
+}
+function parseOpenAiCompatibleChatCompletionResponse(args) {
+  const choiceMessage = args.data?.choices?.[0]?.message ?? {};
+  const rawContent = String(choiceMessage?.content ?? "");
+  const { content, reasoning } = extractThinkContent(rawContent);
+  const rawFinishReason = args.data?.choices?.[0]?.finish_reason;
+  return {
+    content,
+    model: args.providerConfig.model,
+    provider: args.providerConfig.provider,
+    ...Array.isArray(choiceMessage?.tool_calls) ? { tool_calls: choiceMessage.tool_calls } : {},
+    ...reasoning ? { reasoning_content: reasoning } : {},
+    ...typeof choiceMessage?.reasoning_content === "string" && choiceMessage.reasoning_content ? { reasoning_content: choiceMessage.reasoning_content } : {},
+    ...typeof rawFinishReason === "string" && rawFinishReason.length > 0 ? { finish_reason: rawFinishReason } : {},
+    usage: args.data?.usage,
+    trace: args.trace
+  };
+}
+function processOpenAiCompatibleSseEvent(event, state) {
+  for (const line of event.split("\n")) {
+    const parsed = parseSseDataLineJson(line);
+    if (parsed == null) continue;
+    applyChatCompletionDelta(parsed, state);
+  }
+}
+async function readOpenAiCompatibleSseCompletion(args) {
+  const state = {
+    content: "",
+    reasoning: "",
+    usage: void 0,
+    accumulatedToolCalls: {},
+    thinkState: createThinkParserState(),
+    onTextDelta: args.onTextDelta,
+    onReasoningDelta: args.onReasoningDelta
+  };
+  for await (const frame of readSseFrames(args.response)) {
+    processOpenAiCompatibleSseEvent(frame, state);
+  }
+  flushChatCompletionStream(state);
+  throwIfChatCompletionStreamFailed(state);
+  const tool_calls = finalizeAccumulatedToolCalls(state.accumulatedToolCalls);
+  return {
+    content: state.content,
+    ...state.reasoning ? { reasoning_content: state.reasoning } : {},
+    ...tool_calls.length > 0 ? { tool_calls } : {},
+    ...state.usage ? { usage: state.usage } : {},
+    ...state.finishReason ? { finish_reason: state.finishReason } : {}
+  };
+}
+async function executeOpenAiCompatibleChatCompletion(args) {
+  const send = async (apiKey2) => {
+    const request = buildOpenAiCompatibleChatCompletionRequest({
+      providerConfig: apiKey2 === args.providerConfig.apiKey ? args.providerConfig : { ...args.providerConfig, apiKey: apiKey2 },
+      messages: args.messages,
+      tools: args.tools,
+      stream: args.stream
+    });
+    return args.fetchImpl(request.url, {
+      ...request.init,
+      ...args.signal ? { signal: args.signal } : {}
+    });
+  };
+  let apiKey = args.providerConfig.apiKey;
+  if (args.resolveApiKey) {
+    apiKey = await args.resolveApiKey({ force: false }) ?? apiKey;
+  }
+  let res = await send(apiKey);
+  if (res.status === 401 && args.resolveApiKey) {
+    const refreshed = await args.resolveApiKey({ force: true });
+    if (refreshed && refreshed !== apiKey) {
+      await res.body?.cancel().catch(() => {
+      });
+      res = await send(refreshed);
+    }
+  }
+  if (!res.ok) {
+    const raw2 = await res.text().catch(() => "");
+    let data2 = raw2;
+    try {
+      data2 = JSON.parse(raw2);
+    } catch {
+    }
+    throw new Error(`local provider failed: HTTP ${res.status} ${JSON.stringify(data2)}`);
+  }
+  const contentType = res.headers.get("content-type") ?? "";
+  const isEventStream = contentType.includes("text/event-stream");
+  if (isEventStream) {
+    const streamed = await readOpenAiCompatibleSseCompletion({
+      response: res,
+      ...args.onTextDelta ? { onTextDelta: args.onTextDelta } : {},
+      ...args.onReasoningDelta ? { onReasoningDelta: args.onReasoningDelta } : {}
+    });
+    return {
+      content: streamed.content,
+      model: args.providerConfig.model,
+      provider: args.providerConfig.provider,
+      ...streamed.tool_calls ? { tool_calls: streamed.tool_calls } : {},
+      ...streamed.reasoning_content ? { reasoning_content: streamed.reasoning_content } : {},
+      ...streamed.usage ? { usage: streamed.usage } : {},
+      ...streamed.finish_reason ? { finish_reason: streamed.finish_reason } : {},
+      trace: args.messages
+    };
+  }
+  const raw = await res.text().catch(() => "");
+  let data = {};
+  try {
+    data = raw ? JSON.parse(raw) : {};
+  } catch {
+    data = {};
+  }
+  return parseOpenAiCompatibleChatCompletionResponse({
+    providerConfig: args.providerConfig,
+    data,
+    trace: args.messages
+  });
+}
+
+// packages/agent-runtime/openAiCompatibleProviderConfig.ts
+async function resolveOpenAiCompatibleProviderConfig(args) {
+  const plan = await buildProviderExecutionPlan({
+    agentConfig: args.agentConfig,
+    env: args.env,
+    runtimeKind: "local",
+    ...args.apiKeyRefResolver ? { apiKeyRefResolver: args.apiKeyRefResolver } : {},
+    ...args.credentialBroker ? { credentialBroker: args.credentialBroker } : {},
+    ...args.syncFetcher ? { syncFetcher: args.syncFetcher } : {}
+  });
+  if (plan.mode === "cli" || plan.transport !== "direct") {
+    throw new Error("OpenAI-compatible provider config requires a direct provider execution plan.");
+  }
+  return {
+    model: plan.model,
+    endpoint: plan.endpoint,
+    apiKey: plan.apiKey,
+    ...plan.apiKeyHeader ? { apiKeyHeader: plan.apiKeyHeader } : {},
+    provider: plan.provider,
+    requestOptions: plan.requestOptions
+  };
+}
+
+// packages/agent-runtime/windowsCredentialManagerBroker.ts
+var WINDOWS_CREDENTIAL_MANAGER_SCRIPT = `
+$ErrorActionPreference = 'Stop'
+try {
+  $raw = [Console]::In.ReadToEnd()
+  if ([string]::IsNullOrWhiteSpace($raw)) { exit 1 }
+  $req = $raw | ConvertFrom-Json
+  $op = [string]$req.op
+  $target = [string]$req.target
+  if ([string]::IsNullOrWhiteSpace($op) -or [string]::IsNullOrWhiteSpace($target)) { exit 1 }
+
+  Add-Type @"
+using System;
+using System.Runtime.InteropServices;
+using System.Text;
+
+public class NoloCredNative {
+  public const int CRED_TYPE_GENERIC = 1;
+  public const int CRED_PERSIST_LOCAL_MACHINE = 2;
+  public const int ERROR_NOT_FOUND = 1168;
+
+  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+  public struct CREDENTIAL {
+    public int Flags;
+    public int Type;
+    public string TargetName;
+    public string Comment;
+    public long LastWritten;
+    public int CredentialBlobSize;
+    public IntPtr CredentialBlob;
+    public int Persist;
+    public int AttributeCount;
+    public IntPtr Attributes;
+    public string TargetAlias;
+    public string UserName;
+  }
+
+  [DllImport("advapi32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+  public static extern bool CredWriteW(ref CREDENTIAL userCredential, uint flags);
+
+  [DllImport("advapi32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+  public static extern bool CredReadW(string target, int type, int reservedFlag, out IntPtr credentialPtr);
+
+  [DllImport("advapi32.dll", CharSet = CharSet.Unicode, SetLastError = true)]
+  public static extern bool CredDeleteW(string target, int type, int flags);
+
+  [DllImport("advapi32.dll", SetLastError = true)]
+  public static extern void CredFree(IntPtr buffer);
+}
+"@
+
+  if ($op -eq 'get') {
+    $ptr = [IntPtr]::Zero
+    $ok = [NoloCredNative]::CredReadW($target, [NoloCredNative]::CRED_TYPE_GENERIC, 0, [ref]$ptr)
+    if (-not $ok) {
+      exit [Runtime.InteropServices.Marshal]::GetLastWin32Error()
+    }
+    try {
+      $cred = [Runtime.InteropServices.Marshal]::PtrToStructure($ptr, [type][NoloCredNative+CREDENTIAL])
+      if ($cred.CredentialBlobSize -le 0 -or $cred.CredentialBlob -eq [IntPtr]::Zero) {
+        $payload = @{ secret = '' } | ConvertTo-Json -Compress
+        [Console]::Out.Write($payload)
+        exit 0
+      }
+      $bytes = New-Object byte[] $cred.CredentialBlobSize
+      [Runtime.InteropServices.Marshal]::Copy($cred.CredentialBlob, $bytes, 0, $cred.CredentialBlobSize)
+      $secret = [Text.Encoding]::UTF8.GetString($bytes)
+      $payload = @{ secret = $secret } | ConvertTo-Json -Compress
+      [Console]::Out.Write($payload)
+      exit 0
+    } finally {
+      [NoloCredNative]::CredFree($ptr)
+    }
+  }
+
+  if ($op -eq 'has') {
+    $ptr = [IntPtr]::Zero
+    $ok = [NoloCredNative]::CredReadW($target, [NoloCredNative]::CRED_TYPE_GENERIC, 0, [ref]$ptr)
+    if (-not $ok) {
+      exit [Runtime.InteropServices.Marshal]::GetLastWin32Error()
+    }
+    [NoloCredNative]::CredFree($ptr)
+    exit 0
+  }
+
+  if ($op -eq 'put') {
+    $secret = [string]$req.secret
+    if ([string]::IsNullOrEmpty($secret)) { exit 1 }
+    $blob = [Text.Encoding]::UTF8.GetBytes($secret)
+    $cred = New-Object NoloCredNative+CREDENTIAL
+    $cred.Type = [NoloCredNative]::CRED_TYPE_GENERIC
+    $cred.TargetName = $target
+    $cred.UserName = 'api-key'
+    $cred.Persist = [NoloCredNative]::CRED_PERSIST_LOCAL_MACHINE
+    $cred.CredentialBlobSize = $blob.Length
+    $cred.CredentialBlob = [Runtime.InteropServices.Marshal]::AllocHGlobal($blob.Length)
+    try {
+      if ($blob.Length -gt 0) {
+        [Runtime.InteropServices.Marshal]::Copy($blob, 0, $cred.CredentialBlob, $blob.Length)
+      }
+      $ok = [NoloCredNative]::CredWriteW([ref]$cred, 0)
+      if (-not $ok) {
+        exit [Runtime.InteropServices.Marshal]::GetLastWin32Error()
+      }
+      exit 0
+    } finally {
+      [Runtime.InteropServices.Marshal]::FreeHGlobal($cred.CredentialBlob)
+    }
+  }
+
+  if ($op -eq 'delete') {
+    $ok = [NoloCredNative]::CredDeleteW($target, [NoloCredNative]::CRED_TYPE_GENERIC, 0)
+    if (-not $ok) {
+      exit [Runtime.InteropServices.Marshal]::GetLastWin32Error()
+    }
+    exit 0
+  }
+
+  exit 1
+} catch {
+  exit 1
+}
+`.trim();
+
+// packages/agent-runtime/agentRecordKeys.ts
+function buildAgentRuntimeAgentLookupKeys(args) {
+  if (/^agent(-pub)?-/.test(args.agentRef)) {
+    return [args.agentRef];
+  }
+  return [`agent-${args.userId}-${args.agentRef}`, `agent-pub-${args.agentRef}`];
+}
+function shouldFetchAgentRuntimeRecordRemotely(dbKey) {
+  return /^agent(-pub)?-/.test(dbKey);
+}
+
+// packages/agent-runtime/dialogMessageRecord.ts
+function dialogMessageRecordToAgentRuntimeMessage(record) {
+  if (!record || typeof record !== "object") return null;
+  if (record.role !== "user" && record.role !== "assistant" && record.role !== "tool") return null;
+  return {
+    role: record.role,
+    content: record.content ?? "",
+    ...typeof record.reasoning_content === "string" ? { reasoning_content: record.reasoning_content } : {},
+    ...typeof record.toolCallId === "string" ? { tool_call_id: record.toolCallId } : {},
+    ...Array.isArray(record.tool_calls) ? { tool_calls: record.tool_calls } : {},
+    ...typeof record.toolName === "string" ? { toolName: record.toolName } : {}
+  };
+}
+
+// packages/agent-runtime/dialogWritePlan.ts
+function extractLastUserText(messages) {
+  const lastUser = [...messages].reverse().find((message) => message.role === "user");
+  if (typeof lastUser?.content === "string") return lastUser.content;
+  if (Array.isArray(lastUser?.content)) {
+    return lastUser.content.filter((part) => part.type === "text").map((part) => part.text).join(" ");
+  }
+  return "";
+}
+function resolveDialogTitle(args) {
+  if (typeof args.existingDialog?.title === "string" && args.existingDialog.title.trim()) {
+    return args.existingDialog.title;
+  }
+  const lastUserText = extractLastUserText(args.messages).trim();
+  return lastUserText ? lastUserText.slice(0, 80) : "Local agent run";
+}
+function normalizeSubjectRef(ref) {
+  if (!ref || typeof ref !== "object") return null;
+  const raw = ref;
+  const kind = asOptionalTrimmedString(raw.kind);
+  const id = asOptionalTrimmedString(raw.id);
+  if (!kind || !id) return null;
+  const role = asOptionalTrimmedString(raw.role);
+  return {
+    kind,
+    id,
+    ...role ? { role } : {}
+  };
+}
+function mergeSubjectRefs(...groups) {
+  const refs = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const group of groups) {
+    if (!Array.isArray(group)) continue;
+    for (const item of group) {
+      const ref = normalizeSubjectRef(item);
+      if (!ref) continue;
+      const key = `${ref.kind}:${ref.id}:${ref.role ?? ""}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      refs.push(ref);
+    }
+  }
+  return refs.length ? refs : void 0;
+}
+function buildRuntimeSubjectRefs(runtimeContext) {
+  return mergeSubjectRefs(runtimeContext?.subjectRefs);
+}
+function buildDialogLineageFields(args) {
+  const inheritedFromDialogKey = asOptionalTrimmedString(args.input.inheritedFromDialogKey);
+  const parentDialogId = asOptionalTrimmedString(args.input.parentDialogId);
+  if (!inheritedFromDialogKey && !parentDialogId) return {};
+  const rootDialogId = asOptionalTrimmedString(args.existingDialog?.rootDialogId) ?? asOptionalTrimmedString(args.existingDialog?.parentDialogId) ?? parentDialogId;
+  return {
+    ...inheritedFromDialogKey ? { inheritedFromDialogKey } : {},
+    ...parentDialogId ? { parentDialogId } : {},
+    ...rootDialogId ? { rootDialogId } : {}
+  };
+}
+function buildDialogMessageWriteOps(args) {
+  return args.input.messages.filter((message) => message.role !== "system").map((message, index) => {
+    const id = `${args.now}-${String(index + 1).padStart(3, "0")}`;
+    const key = dialogMessageKey(args.dialogId, id);
+    const toolName = asOptionalTrimmedString(message.toolName);
+    return {
+      type: "put",
+      key,
+      value: {
+        id,
+        dbKey: key,
+        dialogId: args.dialogId,
+        role: message.role,
+        content: message.content ?? "",
+        // 持久化思维链(reasoning):空轮/异常排查的关键证据,
+        // 回读由 dialogMessageRecordToAgentRuntimeMessage 还原。
+        ...typeof message.reasoning_content === "string" ? { reasoning_content: message.reasoning_content } : {},
+        ...message.role === "user" ? { userId: args.userId } : {},
+        ...message.role === "assistant" ? {
+          agentKey: args.input.agentKey,
+          cybotKey: args.input.agentKey
+        } : {},
+        ...message.tool_call_id ? { toolCallId: message.tool_call_id } : {},
+        ...toolName ? { toolName } : {},
+        ...Array.isArray(message.tool_calls) ? { tool_calls: message.tool_calls } : {},
+        ...message.tool_result_metadata ? { metadata: message.tool_result_metadata } : {},
+        createdAt: args.nowIso
+      }
+    };
+  });
+}
+function buildAgentRuntimeDialogWritePlan(args) {
+  const dialogId = args.input.continueDialogId || args.createId();
+  const nowIso = new Date(args.now).toISOString();
+  const dialogKey = `dialog-${args.userId}-${dialogId}`;
+  const subjectRefs = buildRuntimeSubjectRefs(args.input.runtimeContext);
+  const dialogRecord = {
+    ...asRecordOrEmpty(args.existingDialog),
+    id: dialogId,
+    dbKey: dialogKey,
+    type: "dialog",
+    userId: args.userId,
+    cybots: [args.input.agentKey],
+    primaryAgentKey: args.input.agentKey,
+    title: typeof args.existingDialog?.title === "string" && args.existingDialog.title.trim() ? args.existingDialog.title.trim() : args.titleOverride?.trim() ? args.titleOverride.trim() : resolveDialogTitle({
+      existingDialog: args.existingDialog,
+      messages: args.input.messages
+    }),
+    status: args.input.result.error === true ? "failed" : "done",
+    triggerType: `${args.runtimeHost}-local`,
+    executionMode: args.existingDialog?.executionMode ?? "foreground",
+    createdAt: args.existingDialog?.createdAt ?? nowIso,
+    updatedAt: nowIso,
+    finishedAt: args.now,
+    usage: args.input.result.usage,
+    ...asOptionalTrimmedString(args.input.spaceId) ? { spaceId: asOptionalTrimmedString(args.input.spaceId) } : {},
+    ...asOptionalTrimmedString(args.input.category) ? { category: asOptionalTrimmedString(args.input.category) } : {},
+    ...subjectRefs ? { subjectRefs } : {},
+    ...buildDialogLineageFields({
+      input: args.input,
+      existingDialog: args.existingDialog
+    }),
+    ...typeof args.input.result.toolCallCount === "number" ? { toolCallCount: args.input.result.toolCallCount } : {},
+    localRuntime: {
+      host: args.runtimeHost,
+      ...args.runtimeMetadata ?? {}
+    },
+    ...args.input.result.runtimeToolSurface ? {
+      runtimeCheckpoint: {
+        ...asRecordOrEmpty(args.existingDialog?.runtimeCheckpoint),
+        toolSurface: args.input.result.runtimeToolSurface
+      }
+    } : {}
+  };
+  return {
+    dialogId,
+    ops: [
+      {
+        type: "put",
+        key: dialogKey,
+        value: dialogRecord
+      },
+      ...buildDialogMessageWriteOps({
+        dialogId,
+        input: args.input,
+        userId: args.userId,
+        now: args.now,
+        nowIso
+      })
+    ]
+  };
+}
+
+// packages/agent-runtime/hybridRecordStore.ts
+function resolveHybridServers(defaultServer, preferredServerOrigin, fallbackServers = []) {
+  const raw = [
+    preferredServerOrigin || "",
+    defaultServer,
+    ...fallbackServers
+  ].filter((value) => value.trim().length > 0);
+  return [...new Set(raw.map(normalizeServerOrigin))];
+}
+function normalizeHybridRecord(dbKey, record, serverOrigin) {
+  if (!record || typeof record !== "object") return null;
+  return {
+    ...record,
+    dbKey: typeof record.dbKey === "string" && record.dbKey ? record.dbKey : dbKey,
+    ...serverOrigin ? { serverOrigin } : {}
+  };
+}
+function getHybridRecordTimestamp(record) {
+  if (!record || typeof record !== "object") return 0;
+  const candidates = [
+    record.updatedAt,
+    record.updated_at,
+    record.createdAt,
+    record.created,
+    record?.meta?.createdAt
+  ];
+  for (const candidate of candidates) {
+    const asNumber = asOptionalPositiveFiniteNumber(candidate);
+    if (asNumber !== void 0) return asNumber;
+    if (typeof candidate === "string" && candidate.trim()) {
+      const parsed = asOptionalPositiveFiniteNumber(Date.parse(candidate));
+      if (parsed !== void 0) return parsed;
+    }
+  }
+  return 0;
+}
+function isHybridTombstoneRecord(record) {
+  if (!record || typeof record !== "object") return false;
+  if (typeof record.deletedAt === "string") return record.deletedAt.trim().length > 0;
+  return Boolean(record.deletedAt);
+}
+function shouldReplaceWithHybridRecord(nextRecord, currentRecord) {
+  const nextTs = getHybridRecordTimestamp(nextRecord);
+  const currentTs = getHybridRecordTimestamp(currentRecord);
+  if (nextTs !== currentTs) return nextTs > currentTs;
+  return isHybridTombstoneRecord(nextRecord) && !isHybridTombstoneRecord(currentRecord);
+}
+function isHybridNotFoundError(error) {
+  const message = toErrorMessage(error);
+  return /not found|notfound|leveldb: not found|key not found/i.test(message);
+}
+async function readHybridLocalRecord(db, dbKey) {
+  try {
+    return await db.get(dbKey);
+  } catch (error) {
+    if (!isHybridNotFoundError(error)) throw error;
+    return null;
+  }
+}
+async function fetchHybridRemoteRecord(args) {
+  const response = await args.fetchImpl(
+    `${args.server}/api/v1/db/read/${encodeURIComponent(args.dbKey)}`,
+    {
+      headers: {
+        "Content-Type": "application/json",
+        ...args.authToken ? { Authorization: `Bearer ${args.authToken}` } : {}
+      },
+      ...args.signal ? { signal: args.signal } : {}
+    }
+  );
+  if (!response.ok) return null;
+  const payload = await response.json().catch(() => null);
+  return normalizeHybridRecord(args.dbKey, payload?.data ?? payload, args.server);
+}
+function shouldCacheHybridRemoteRecord(remoteRecord, localRecord) {
+  if (!remoteRecord || typeof remoteRecord !== "object") return false;
+  if (!localRecord || typeof localRecord !== "object") return true;
+  return shouldReplaceWithHybridRecord(remoteRecord, localRecord);
+}
+function createHybridRecordStore(deps) {
+  const fetchImpl = deps.fetchImpl ?? fetch;
+  return {
+    read: async (dbKey, options) => {
+      const localRecord = await readHybridLocalRecord(deps.db, dbKey);
+      const normalizedLocalRecord = normalizeHybridRecord(dbKey, localRecord);
+      if (normalizedLocalRecord && options?.remote !== true) return normalizedLocalRecord;
+      if (options?.remote === false) return null;
+      for (const server of resolveHybridServers(
+        deps.defaultServer,
+        options?.preferredServerOrigin,
+        deps.fallbackServers
+      )) {
+        let remoteRecord = null;
+        try {
+          remoteRecord = await fetchHybridRemoteRecord({
+            dbKey,
+            server,
+            authToken: deps.authToken,
+            fetchImpl,
+            ...deps.requestTimeoutMs ? { signal: AbortSignal.timeout(deps.requestTimeoutMs) } : {}
+          });
+        } catch {
+          continue;
+        }
+        if (!remoteRecord) continue;
+        if (shouldCacheHybridRemoteRecord(remoteRecord, localRecord)) {
+          await deps.db.put(dbKey, remoteRecord);
+          return remoteRecord;
+        }
+        return normalizedLocalRecord ?? remoteRecord;
+      }
+      return normalizedLocalRecord ?? null;
+    },
+    write: async (dbKey, record) => {
+      const nextRecord = normalizeHybridRecord(dbKey, record) ?? { dbKey };
+      await deps.db.put(dbKey, nextRecord);
+      return nextRecord;
+    },
+    batch: async (ops) => deps.db.batch(ops.map((op) => ({
+      ...op,
+      value: normalizeHybridRecord(op.key, op.value) ?? { dbKey: op.key }
+    }))),
+    iterator: (options) => deps.db.iterator(options)
+  };
+}
+
+// packages/agent-runtime/shellCommandPolicy.ts
+var DESTRUCTIVE_NEGATION_PATTERNS = [
+  "\u522B\u5220",
+  "\u522B\u5220\u9664",
+  "\u4E0D\u8981\u5220",
+  "\u4E0D\u8981\u5220\u9664",
+  "\u522B\u4E71\u5220",
+  "\u522B\u52A8",
+  "\u4E0D\u8981\u52A8",
+  "\u4E0D\u8981\u6E05\u7406",
+  "\u4E0D\u8981\u6E05\u7A7A",
+  "\u4E0D\u8981\u91CD\u7F6E",
+  "don't delete",
+  "do not delete",
+  "don't remove",
+  "do not remove",
+  "without deleting"
+];
+var EXPLICIT_DESTRUCTIVE_REQUEST_PATTERNS = [
+  "\u5220\u9664",
+  "\u5220\u6389",
+  "\u79FB\u9664",
+  "\u6E05\u7406",
+  "\u6E05\u7A7A",
+  "\u91CD\u7F6E",
+  "drop",
+  "delete",
+  "remove",
+  "erase",
+  "clean up",
+  "reset"
+];
+var SHELL_DESTRUCTIVE_PATTERNS = [
+  /\brm\s+(-[^\n\r]*\s+)?/i,
+  /\bremove-item\b/i,
+  /\bdel\s+\/?[a-z]*\s+/i,
+  /\berase\s+/i,
+  /\brmdir\s+/i,
+  /\brd\s+\/s\b/i,
+  /\bgit\s+reset\s+(--hard\b|--merge\b|--keep\b)/i,
+  /\bgit\s+clean\s+-[^\n\r]*f/i,
+  /\bgit\s+checkout\s+--\b/i,
+  /\bgit\s+restore\s+--source=/i
+];
+var SHELL_STRING_EXECUTION_PATTERNS = [
+  /\b(?:ba|da|z|k)?sh\b/i,
+  /\beval\b/i,
+  /\bexec\b/i,
+  /\bxargs\b/i,
+  /\bsource\s/i,
+  /\b(?:node|deno|bun)\s+(?:-\S+\s+)*(?:-e|--eval)\b/i,
+  /\bpython[\d.]*\s+(?:-\S+\s+)*-c\b/i,
+  /\b(?:perl|ruby)\s+(?:-\S+\s+)*-e\b/i
+];
+var stripQuotedSegments = (text) => {
+  let out = "";
+  let i = 0;
+  while (i < text.length) {
+    const ch = text[i];
+    if (ch === "\\") {
+      out += text.slice(i, i + 2);
+      i += 2;
+    } else if (ch === "'") {
+      const end = text.indexOf("'", i + 1);
+      if (end === -1) return out + text.slice(i);
+      out += "''";
+      i = end + 1;
+    } else if (ch === '"') {
+      let j = i + 1;
+      while (j < text.length && text[j] !== '"') {
+        j += text[j] === "\\" ? 2 : 1;
+      }
+      if (j >= text.length) return out + text.slice(i);
+      out += '""';
+      i = j + 1;
+    } else {
+      out += ch;
+      i += 1;
+    }
+  }
+  return out;
+};
+var normalizeUserInput = (value) => asTrimmedLowercaseString(value);
+var containsAny = (text, patterns) => patterns.some((pattern) => text.includes(pattern));
+var hasExplicitDestructivePermission = (userInput) => {
+  const normalized = normalizeUserInput(userInput);
+  if (!normalized) return false;
+  if (containsAny(normalized, DESTRUCTIVE_NEGATION_PATTERNS)) return false;
+  return containsAny(normalized, EXPLICIT_DESTRUCTIVE_REQUEST_PATTERNS);
+};
+var SHELL_COMMAND_ARG_ALIASES = [
+  "command",
+  "runCommand",
+  "run_command",
+  "terminalCommand",
+  "terminal_command",
+  "runInBash",
+  "run_in_bash",
+  "executeCommand",
+  "execute_command",
+  "execShell",
+  "bash",
+  "cmd"
+];
+var resolveShellCommandArg = (args) => {
+  if (!args) return void 0;
+  for (const key of SHELL_COMMAND_ARG_ALIASES) {
+    const value = args[key];
+    if (value != null) return value;
+  }
+  return void 0;
+};
+var buildCombinedShellInput = (args) => {
+  const command = resolveShellCommandArg(args);
+  return [
+    typeof command === "string" ? command : "",
+    typeof args.input === "string" ? args.input : ""
+  ].filter(Boolean).join("\n");
+};
+function isDestructiveShellCommand(args) {
+  const combined = buildCombinedShellInput(args);
+  if (!combined.trim()) return false;
+  const scannable = SHELL_STRING_EXECUTION_PATTERNS.some(
+    (pattern) => pattern.test(combined)
+  ) ? combined : stripQuotedSegments(combined);
+  return SHELL_DESTRUCTIVE_PATTERNS.some((pattern) => pattern.test(scannable));
+}
+var LONG_RUNNING_COMMAND_PATTERNS = [
+  /\b(run|npm|yarn|pnpm|bun|npx)\s+(run\s+)?(dev|serve|start|watch)\b/i,
+  /(^|[\s=&|;])--watch\b/i,
+  /\bvite\b.*\b(dev|serve)\b/i,
+  /\bwebpack\b.*(?:--watch|serve)\b/i,
+  /\bnodemon\b/i,
+  /\bgatsby\b.*\b(develop|serve)\b/i,
+  /\bnext\b.*\b(dev|start)\b/i,
+  /\belectron\b.*\bdev\b/i,
+  /\bforever\b/i,
+  /\bpm2\b.*\bstart\b/i
+];
+function isLongRunningShellCommand(args) {
+  const combined = buildCombinedShellInput(args);
+  if (!combined.trim()) return false;
+  const scannable = SHELL_STRING_EXECUTION_PATTERNS.some(
+    (pattern) => pattern.test(combined)
+  ) ? combined : stripQuotedSegments(combined);
+  return LONG_RUNNING_COMMAND_PATTERNS.some((pattern) => pattern.test(scannable));
+}
+function evaluateShellCommandPolicy(args) {
+  if (isDestructiveShellCommand(args) && !hasExplicitDestructivePermission(args.userInput)) {
+    return {
+      verdict: "forbidden",
+      permissionDecision: "ask",
+      code: "destructive_action_requires_confirmation",
+      reason: "\u5F53\u524D\u8FD0\u884C\u9ED8\u8BA4\u7981\u6B62\u81EA\u52A8\u6267\u884C\u53EF\u80FD\u5220\u9664\u7528\u6237\u5185\u5BB9\u7684 shell \u547D\u4EE4\u3002\u53EA\u6709\u5F53\u7528\u6237\u5728\u5F53\u524D\u8BF7\u6C42\u91CC\u660E\u786E\u8981\u6C42\u5220\u9664/\u6E05\u7406\u65F6\uFF0C\u624D\u80FD\u7EE7\u7EED\uFF1B\u5426\u5219\u8BF7\u505C\u6B62\u5E76\u5148\u8BF4\u660E\u9650\u5236\u3002",
+      permissionRequest: {
+        id: "permission-shell-destructive-action",
+        tool: "execShell",
+        action: "destructive_shell_command",
+        title: "\u786E\u8BA4\u6267\u884C\u7834\u574F\u6027 shell \u547D\u4EE4",
+        body: "\u8BE5\u547D\u4EE4\u53EF\u80FD\u5220\u9664\u6216\u91CD\u7F6E\u7528\u6237\u5185\u5BB9\uFF0C\u9700\u8981\u7528\u6237\u660E\u786E\u786E\u8BA4\u540E\u624D\u80FD\u6267\u884C\u3002",
+        suggestedRule: {
+          scope: "once",
+          pattern: { capability: "destructive_action", target: "shell_command" }
+        }
+      },
+      policy: {
+        capability: "destructive_action",
+        target: "shell_command",
+        detail: "execShell destructive command"
+      }
+    };
+  }
+  const longRunningHint = isLongRunningShellCommand(args);
+  return {
+    verdict: "allowed",
+    permissionDecision: "allow",
+    ...longRunningHint ? { longRunningHint: true } : {}
+  };
+}
+
+// packages/agent-runtime/localToolPolicy.ts
+var NEVER_LOCAL_TOOLS = /* @__PURE__ */ new Set([
+  "deleteSpaces",
+  "updateAgent",
+  "updateSelf",
+  "createAgent"
+]);
+var REMOVED_LOCAL_TOOLS = /* @__PURE__ */ new Set([
+  "gitStatus",
+  "gitDiff",
+  "gitCreateBranch",
+  "gitAdd",
+  "gitCommit",
+  "commitWorkspace"
+]);
+var DEFAULT_LOCAL_TOOLS = /* @__PURE__ */ new Set([
+  "listFiles",
+  "readFile",
+  "writeFile",
+  "editFile",
+  "globFiles",
+  "searchFiles",
+  "execShell",
+  "launchProcess",
+  "listProcesses"
+]);
+function parseToolAllowlist(value) {
+  return (value ?? "").split(",").flatMap((item) => {
+    const trimmed = item.trim();
+    return trimmed ? [trimmed] : [];
+  });
+}
+function normalizeLocalToolName(toolName) {
+  return canonicalizeToolName(
+    String(toolName ?? "").replace(/^functions\./, "").trim()
+  );
+}
+function parseShellCommandPayload(rawArguments) {
+  return parseToolArgumentsJson(rawArguments);
+}
+function toDisplayCommand(command) {
+  if (typeof command === "string") {
+    const trimmed = command.trim();
+    return trimmed ? trimmed : void 0;
+  }
+  if (Array.isArray(command)) {
+    const joined = command.map((item) => typeof item === "string" ? item : String(item)).filter((item) => item.length > 0).join(" ").trim();
+    return joined ? joined : void 0;
+  }
+  return void 0;
+}
+function isRestrictedLocalToolMode(env) {
+  return env.NOLO_LOCAL_TOOL_MODE === "restricted";
+}
+function resolveLocalToolPolicy(args) {
+  const toolName = normalizeLocalToolName(args.toolName);
+  const restrictedMode = isRestrictedLocalToolMode(args.env);
+  if (!toolName) {
+    return {
+      allowed: false,
+      toolName,
+      reason: "Tool name is required."
+    };
+  }
+  if (NEVER_LOCAL_TOOLS.has(toolName)) {
+    return {
+      allowed: false,
+      toolName,
+      reason: `${toolName} is blocked by the local runtime safety policy.`
+    };
+  }
+  if (REMOVED_LOCAL_TOOLS.has(toolName)) {
+    return {
+      allowed: false,
+      toolName,
+      reason: `${toolName} has been removed from the local runtime tool surface. Use execShell in shell-enabled workspace runs when shell is needed.`
+    };
+  }
+  const allowedByEnv = new Set(parseToolAllowlist(args.env.NOLO_LOCAL_ALLOWED_TOOLS));
+  const agentTools = new Set(
+    (args.agentToolNames ?? []).flatMap((item) => {
+      const normalized = normalizeLocalToolName(item);
+      return normalized ? [normalized] : [];
+    })
+  );
+  if (!restrictedMode && agentTools.has(toolName)) {
+    return { allowed: true, toolName };
+  }
+  if (DEFAULT_LOCAL_TOOLS.has(toolName) && agentTools.has(toolName)) {
+    return { allowed: true, toolName };
+  }
+  if (allowedByEnv.has(toolName) && agentTools.has(toolName)) {
+    return { allowed: true, toolName };
+  }
+  return {
+    allowed: false,
+    toolName,
+    reason: `${toolName} is not enabled for local runtime runs. Set NOLO_LOCAL_ALLOWED_TOOLS and make sure the agent declares the tool before using it locally.`
+  };
+}
+async function executeLocalToolWithPolicy(args) {
+  const decision = resolveLocalToolPolicy({
+    env: args.env,
+    agentToolNames: args.agentToolNames,
+    toolName: args.call.name
+  });
+  if (!decision.allowed) throw new Error(decision.reason);
+  const executor = args.executors?.[decision.toolName];
+  if (!executor) {
+    throw new Error(`${decision.toolName} is allowed by policy but no local executor is registered.`);
+  }
+  const effectiveExecutor = args.abortSignal && decision.toolName === "execShell" && args.executors ? (call) => args.executors.execShell(call, {
+    abortSignal: args.abortSignal,
+    detachMs: args.detachMs
+  }) : executor;
+  const guardEnabled = args.enableDestructiveShellGuard !== false;
+  if (decision.toolName === "execShell" && !args.confirmed && guardEnabled) {
+    const parsed = parseShellCommandPayload(args.call.arguments);
+    const rawCommand = resolveShellCommandArg(parsed);
+    if (isDestructiveShellCommand({ command: rawCommand, input: parsed.input })) {
+      const command = toDisplayCommand(rawCommand);
+      const request = {
+        id: "permission-shell-destructive-action",
+        tool: "execShell",
+        action: "destructive_shell_command",
+        title: "\u786E\u8BA4\u6267\u884C\u7834\u574F\u6027 shell \u547D\u4EE4",
+        body: "\u8BE5\u547D\u4EE4\u53EF\u80FD\u5220\u9664\u6216\u91CD\u7F6E\u7528\u6237\u5185\u5BB9\uFF0C\u9700\u8981\u7528\u6237\u660E\u786E\u786E\u8BA4\u540E\u624D\u80FD\u6267\u884C\u3002",
+        ...command ? { command } : {},
+        suggestedRule: {
+          scope: "once",
+          pattern: { capability: "destructive_action", target: "shell_command" }
+        }
+      };
+      const buildBlockedError = (reason) => {
+        const error = new Error(reason);
+        error.code = "destructive_action_requires_confirmation";
+        error.policy = {
+          capability: "destructive_action",
+          target: "shell_command",
+          detail: "execShell destructive command"
+        };
+        error.permissionRequest = request;
+        return error;
+      };
+      if (!args.confirmDestructiveAction) {
+        if (args.blockDestructiveWithoutConfirmation) {
+          throw buildBlockedError(
+            "destructive shell command blocked: no confirmation channel available"
+          );
+        }
+        return effectiveExecutor({
+          ...args.call,
+          name: decision.toolName
+        });
+      }
+      const confirmed = await args.confirmDestructiveAction(request);
+      if (!confirmed) {
+        throw buildBlockedError(
+          "destructive shell command blocked: user declined confirmation"
+        );
+      }
+    }
+  }
+  return effectiveExecutor({
+    ...args.call,
+    name: decision.toolName
+  });
+}
+
+// packages/agent-runtime/localWorkspaceTools.ts
+import { existsSync } from "node:fs";
+import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
+import { dirname, relative, resolve, sep } from "node:path";
+import { spawnSync, spawn as spawnChildProcess } from "node:child_process";
+
+// packages/agent-runtime/processRegistry.ts
+var ProcessRegistry = class {
+  processes = /* @__PURE__ */ new Map();
+  add(proc) {
+    this.processes.set(proc.pid, {
+      pid: proc.pid,
+      pgid: proc.pgid,
+      command: proc.command,
+      label: proc.label,
+      startedAt: Date.now(),
+      status: "running"
+    });
+  }
+  list() {
+    return Array.from(this.processes.values()).map((proc) => ({ ...proc }));
+  }
+  get(pid) {
+    const item = this.processes.get(pid);
+    return item ? { ...item } : void 0;
+  }
+  kill(pid, signal = "SIGTERM") {
+    const item = this.processes.get(pid);
+    if (!item) return false;
+    if (item.status === "running") {
+      try {
+        process.kill(-item.pgid, signal);
+      } catch {
+      }
+      item.status = "stopped";
+      return true;
+    }
+    return false;
+  }
+  stopAll(signal = "SIGTERM") {
+    for (const item of this.processes.values()) {
+      if (item.status === "running") {
+        try {
+          process.kill(-item.pgid, signal);
+        } catch {
+        }
+        item.status = "stopped";
+      }
+    }
+  }
+  markExited(pid, exitCode) {
+    const item = this.processes.get(pid);
+    if (item && item.status === "running") {
+      item.exitCode = exitCode;
+      item.status = exitCode === 0 ? "exited" : "failed";
+    }
+  }
+  clear() {
+    this.processes.clear();
+  }
+};
+var registry = null;
+function getProcessRegistry() {
+  if (!registry) {
+    registry = new ProcessRegistry();
+  }
+  return registry;
+}
+
+// packages/agent-runtime/localWorkspaceToolDefs.ts
+var WORKSPACE_TOOL_NAMES = [
+  "listFiles",
+  "readFile",
+  "writeFile",
+  "editFile",
+  "globFiles",
+  "searchFiles",
+  "captureVisualState",
+  "execShell",
+  "launchProcess",
+  "listProcesses"
+];
+var SHELL_TOOL_NAMES = ["execShell", "launchProcess", "listProcesses"];
+var WORKSPACE_TOOL_NAME_SET = new Set(WORKSPACE_TOOL_NAMES);
+var REMOVED_WORKSPACE_TOOL_NAMES = /* @__PURE__ */ new Set([
+  "gitStatus",
+  "gitDiff",
+  "gitCreateBranch",
+  "gitAdd",
+  "gitCommit",
+  "commitWorkspace"
+]);
+function tokenizeShellPrefix(command) {
+  const tokens = [];
+  const pattern = /"([^"]*)"|'([^']*)'|([^\s"'|;&<>]+)/g;
+  let match;
+  while (match = pattern.exec(command)) {
+    tokens.push(match[1] ?? match[2] ?? match[3] ?? "");
+  }
+  return tokens;
+}
+function buildWorkspacePathProperty() {
+  return {
+    type: "string",
+    description: "Path relative to the workspace root."
+  };
+}
+function buildListWorkspaceDescription(variant) {
+  if (variant === "brief") {
+    return "List files and directories inside a workspace directory.";
+  }
+  if (variant === "workflow") {
+    return "List a bounded directory overview inside the workspace. Use first when you need to understand nearby structure, choose a subdirectory, or inspect a non-code project. Then use globFiles for path-pattern discovery, searchFiles for text/content discovery, and readFile only for the specific files or line ranges you need.";
+  }
+  if (variant === "antiShell") {
+    return "List a bounded directory overview inside the workspace. Do not use execShell with ls/find/tree for normal directory overviews when listFiles can show the needed depth and limit. Use globFiles for path-pattern discovery and searchFiles for content search.";
+  }
+  return "List a bounded directory overview inside the workspace. Use for scanning nearby structure, not for path-pattern discovery across the repo. Prefer globFiles for finding files by name/extension and searchFiles for text inside files.";
+}
+function buildListWorkspaceParameters(variant) {
+  const path = buildWorkspacePathProperty();
+  const maxDepth = {
+    type: "integer",
+    description: "Maximum directory depth to include. Defaults to 1 for the requested directory only."
+  };
+  const maxResults = {
+    type: "integer",
+    description: "Maximum number of entries to return. Use a small value for large directories."
+  };
+  const entryType = {
+    type: "string",
+    enum: ["all", "files", "directories"],
+    description: "Filter returned entries. Defaults to all."
+  };
+  if (variant === "minimal") {
+    return {
+      type: "object",
+      properties: { path }
+    };
+  }
+  if (variant === "rich") {
+    return {
+      type: "object",
+      properties: {
+        path,
+        maxDepth,
+        maxResults,
+        entryType
+      }
+    };
+  }
+  return {
+    type: "object",
+    properties: {
+      path,
+      maxResults
+    }
+  };
+}
+function buildListWorkspaceFilesTool(args) {
+  return {
+    type: "function",
+    function: {
+      name: "listFiles",
+      description: buildListWorkspaceDescription(args?.descriptionVariant),
+      parameters: buildListWorkspaceParameters(args?.parameterVariant)
+    }
+  };
+}
+function buildReadWorkspaceDescription(variant) {
+  if (variant === "brief") {
+    return "Read a UTF-8 text file inside the workspace.";
+  }
+  if (variant === "workflow") {
+    return "Read a UTF-8 text file inside the workspace after listFiles, globFiles, or searchFiles has narrowed the target. Use line ranges from searchFiles matches and tailLines for logs or generated output. Read the whole file only when the task truly needs all content or exact edit context.";
+  }
+  if (variant === "antiShell") {
+    return "Read a UTF-8 text file inside the workspace. Do not use execShell with cat/sed/head/tail for normal text reads when readFile can return the needed file or line range. Use searchFiles first for content search, then readFile only the relevant lines when possible.";
+  }
+  return "Read a UTF-8 text file inside the workspace. Read before editing when you need exact text for editFile. For discovery or classification tasks, avoid batch-reading every candidate; report candidate paths first, or read only one to three representative files with maxLines or focused line ranges. Use line ranges for large code, docs, data, configs, and logs after searchFiles returns line numbers. Read the whole file only when the task truly needs all content or exact edit context.";
+}
+function buildReadWorkspaceParameters(variant) {
+  const path = buildWorkspacePathProperty();
+  const startLine = {
+    type: "integer",
+    description: "1-based first line to return. Use with endLine or maxLines after searchFiles gives a line number."
+  };
+  const endLine = {
+    type: "integer",
+    description: "1-based last line to return, inclusive."
+  };
+  const maxLines = {
+    type: "integer",
+    description: "Maximum number of lines to return starting at startLine, or from the start of the file when startLine is omitted. Use for lightweight previews of candidate configs, docs, data, and logs instead of reading many whole files. When the user gives a read/preview budget, each readFile preview consumes one budget slot."
+  };
+  const tailLines = {
+    type: "integer",
+    description: "Return only the last N lines, useful for logs and generated text."
+  };
+  if (variant === "minimal") {
+    return {
+      type: "object",
+      properties: { path },
+      required: ["path"]
+    };
+  }
+  if (variant === "rich") {
+    return {
+      type: "object",
+      properties: {
+        path,
+        startLine,
+        endLine,
+        maxLines,
+        tailLines
+      },
+      required: ["path"]
+    };
+  }
+  return {
+    type: "object",
+    properties: {
+      path,
+      startLine,
+      endLine,
+      maxLines
+    },
+    required: ["path"]
+  };
+}
+function buildReadWorkspaceFileTool(args) {
+  return {
+    type: "function",
+    function: {
+      name: "readFile",
+      description: buildReadWorkspaceDescription(args?.descriptionVariant),
+      parameters: buildReadWorkspaceParameters(args?.parameterVariant)
+    }
+  };
+}
+function buildWriteWorkspaceFileTool() {
+  return {
+    type: "function",
+    function: {
+      name: "writeFile",
+      description: "Write full UTF-8 file content inside the workspace. For new files or deliberate whole-file rewrites only. For existing files, prefer editFile for targeted edits. Warn that whole-file rewrites can cause line-ending churn.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: buildWorkspacePathProperty(),
+          content: {
+            type: "string",
+            description: "Full UTF-8 file content to write."
+          }
+        },
+        required: ["path", "content"]
+      }
+    }
+  };
+}
+function buildReplaceWorkspaceTextTool() {
+  return {
+    type: "function",
+    function: {
+      name: "editFile",
+      description: "Use for small, exact edits in one workspace file without constructing a patch. Read the file first when you need the exact oldText; set expectedReplacements to avoid accidental broad edits. When expected replacement count fails, report a blocker instead of falling back to a full-file rewrite.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: buildWorkspacePathProperty(),
+          oldText: {
+            type: "string",
+            description: "Exact text currently present in the file."
+          },
+          newText: {
+            type: "string",
+            description: "Replacement text to write in place of oldText."
+          },
+          expectedReplacements: {
+            type: "integer",
+            description: "Expected replacement count. Defaults to 1."
+          }
+        },
+        required: ["path", "oldText", "newText"]
+      }
+    }
+  };
+}
+function buildSearchWorkspaceDescription(variant) {
+  if (variant === "brief") {
+    return "Search workspace file contents.";
+  }
+  if (variant === "workflow") {
+    return "Search file contents inside the current workspace after listFiles or globFiles has scoped the likely area, or directly when the task names text to find. Use for code, docs, data, configs, logs, and other text files. Return line numbers, then use readFile with focused ranges for interpretation or editing.";
+  }
+  if (variant === "antiShell") {
+    return "Search text inside workspace files for code, docs, data, configs, logs, or other text-like assets. Do not use execShell for content search when searchFiles can directly find matching lines. Use globFiles instead for path-only discovery, then readFile for exact surrounding content when needed.";
+  }
+  return "Search file contents inside the current workspace using ripgrep when available. Use for grep-like text or regex search across code, docs, data, configs, logs, and other text files. Use globFiles instead when you only need to find files by name or extension before readFile.";
+}
+function buildSearchWorkspaceParameters(variant) {
+  const query = {
+    type: "string",
+    description: "Search query. Treated as a regular expression unless literal is true."
+  };
+  const path = buildWorkspacePathProperty();
+  const includeIgnored = {
+    type: "boolean",
+    description: "When true, search files ignored by .gitignore such as .tmp. Defaults to false; .git and node_modules remain excluded."
+  };
+  const exclude = {
+    type: "array",
+    items: { type: "string" },
+    description: "Glob patterns to exclude from content search, for example ['dist/**', 'build/**', 'exports/**', '*.log']."
+  };
+  const maxResults = {
+    type: "integer",
+    description: "Maximum number of matching output lines to return. Use a small value when you only need candidate files or examples."
+  };
+  const literal = {
+    type: "boolean",
+    description: "When true, search for query as literal text instead of a regular expression."
+  };
+  const caseSensitive = {
+    type: "boolean",
+    description: "When false, search case-insensitively. Defaults to true."
+  };
+  const contextLines = {
+    type: "integer",
+    description: "Number of surrounding context lines to include around each match. Defaults to 0."
+  };
+  if (variant === "minimal") {
+    return {
+      type: "object",
+      properties: { query },
+      required: ["query"]
+    };
+  }
+  if (variant === "rich") {
+    return {
+      type: "object",
+      properties: {
+        query,
+        path,
+        exclude,
+        includeIgnored,
+        maxResults,
+        literal,
+        caseSensitive,
+        contextLines
+      },
+      required: ["query"]
+    };
+  }
+  return {
+    type: "object",
+    properties: {
+      query,
+      path,
+      includeIgnored,
+      maxResults
+    },
+    required: ["query"]
+  };
+}
+function buildSearchWorkspaceTool(args) {
+  return {
+    type: "function",
+    function: {
+      name: "searchFiles",
+      description: buildSearchWorkspaceDescription(args?.descriptionVariant),
+      parameters: buildSearchWorkspaceParameters(args?.parameterVariant)
+    }
+  };
+}
+function buildGlobWorkspaceDescription(variant) {
+  if (variant === "brief") {
+    return "Find workspace files by path glob without reading file contents.";
+  }
+  if (variant === "workflow") {
+    return "Find files by glob pattern inside the current workspace without reading file contents. Use after listFiles when you know the likely area, or first when the task names a filename, extension, asset type, config, or document pattern. Then use searchFiles for text inside candidates or readFile for the specific candidate paths.";
+  }
+  if (variant === "antiShell") {
+    return "Find workspace files by path glob without reading file contents. Use for code, docs, data, images, configs, logs, or any file discovery task. Do not use execShell or listFiles for path discovery when globFiles can directly narrow candidate files. Use before opening or reading files, and use searchFiles instead for searching text inside files.";
+  }
+  return "Find files by glob pattern inside the current workspace without reading file contents. Use for code, docs, data, images, configs, logs, or any file discovery task. Use one bounded glob with brace groups before repeated narrow globs when a task names several extensions or config names, for example **/*.{png,jpg,svg}, **/{package.json,bunfig.toml,tsconfig*.json}, or src/**/*.ts. Prefer searchFiles for searching text inside files, and readFile only after candidate paths are narrow enough.";
+}
+function buildGlobWorkspaceParameters(variant) {
+  const pattern = {
+    type: "string",
+    description: "Glob pattern for files. For candidate discovery, combine related names or extensions in one brace-group pattern before making repeated narrow calls, for example '**/*.ts', 'packages/**/local*.test.ts', '**/*.{png,jpg,svg}', or '**/{package.json,bunfig.toml,tsconfig*.json}'."
+  };
+  const path = buildWorkspacePathProperty();
+  const includeIgnored = {
+    type: "boolean",
+    description: "When true, include files ignored by .gitignore. Defaults to false; .git and node_modules remain excluded."
+  };
+  const maxResults = {
+    type: "integer",
+    description: "Maximum number of file paths to return. Use a small value when you only need candidate paths before readFile; if results are truncated, report that and narrow the pattern or path before reading."
+  };
+  const exclude = {
+    type: "array",
+    items: { type: "string" },
+    description: "Glob patterns to exclude from results, for example ['dist/**', 'build/**', 'exports/**', '*.tmp']."
+  };
+  if (variant === "minimal") {
+    return {
+      type: "object",
+      properties: { pattern },
+      required: ["pattern"]
+    };
+  }
+  if (variant === "rich") {
+    return {
+      type: "object",
+      properties: {
+        pattern,
+        path,
+        exclude,
+        includeIgnored,
+        maxResults
+      },
+      required: ["pattern"]
+    };
+  }
+  return {
+    type: "object",
+    properties: {
+      pattern,
+      glob: {
+        type: "string",
+        description: "Alias for pattern, kept for compatibility with codeSearch-style prompts."
+      },
+      path,
+      exclude,
+      includeIgnored,
+      maxResults
+    }
+  };
+}
+function buildGlobWorkspaceFilesTool(args) {
+  return {
+    type: "function",
+    function: {
+      name: "globFiles",
+      description: buildGlobWorkspaceDescription(args?.descriptionVariant),
+      parameters: buildGlobWorkspaceParameters(args?.parameterVariant)
+    }
+  };
+}
+function buildCaptureVisualStateTool() {
+  return {
+    type: "function",
+    function: {
+      name: "captureVisualState",
+      description: "Capture a real local app screenshot and DOM/computed-style metrics for a selected UI state.",
+      parameters: {
+        type: "object",
+        properties: {
+          baseUrl: {
+            type: "string",
+            description: "Optional local app base URL. Defaults to http://127.0.0.1:38123."
+          },
+          path: {
+            type: "string",
+            description: "App route to open, for example / or /dialog-123. Defaults to /."
+          },
+          waitSelector: {
+            type: "string",
+            description: "CSS selector that must become visible before capture."
+          },
+          scrollSelector: {
+            type: "string",
+            description: "Optional CSS selector to scroll into view before capture."
+          },
+          focusSelector: {
+            type: "string",
+            description: "Optional CSS selector for the target element whose rect/style should be reported."
+          },
+          expectText: {
+            type: "string",
+            description: "Optional visible text expected on the page before capture."
+          },
+          screenshotPath: {
+            type: "string",
+            description: "Workspace-relative screenshot path. Defaults under test-results/frontend-agent/."
+          },
+          metricsPath: {
+            type: "string",
+            description: "Workspace-relative metrics JSON path. Defaults under test-results/frontend-agent/."
+          }
+        },
+        required: ["waitSelector"]
+      }
+    }
+  };
+}
+function buildExecShellTool(toolName) {
+  return {
+    type: "function",
+    function: {
+      name: toolName,
+      description: "Run a shell command in the local workspace. Commands already execute from the workspace root; do not cd into guessed paths such as /workspace, /repo, /home/user, or /home/user/workspace. Prefer one command that performs a complete verification or related git operation instead of many tiny commands. For branch setup, prefer idempotent commands such as git switch -C <branch> when replacing or recreating a benchmark branch is acceptable. Use portable POSIX commands for macOS/BSD shells; avoid GNU-only flags such as cat -A. Do not use cat -A. Do not use brittle byte-offset commands such as xxd -s -32. For separator lines, use echo or printf '%s\\n'. For text-file content or trailing-newline checks, prefer readFile over shell byte inspection when that tool is available. Do not run repeated git status, git log, git rev-parse, or branch checks after a successful command already returned the needed clean status and commit information; use one final verification command. If a command fails, use the error output to adjust the next command rather than repeating the same shape. For long-running commands that should keep running in the background (dev servers, watchers, REPLs, `--watch`/`serve`/`dev` scripts), use launchProcess instead \u2014 execShell blocks until the command exits and will freeze the conversation.",
+      parameters: {
+        type: "object",
+        properties: {
+          cmd: {
+            type: "string",
+            description: "Shell command to run."
+          },
+          command: {
+            type: "string",
+            description: "Shell command to run."
+          }
+        }
+      }
+    }
+  };
+}
+function buildLaunchProcessTool() {
+  return {
+    type: "function",
+    function: {
+      name: "launchProcess",
+      description: "Launch a long-running process (dev server, watcher, REPL) in the background and return immediately without blocking the conversation. Use this instead of execShell for commands that do not exit on their own. Returns {pid, label, status:'running'}. The process keeps running after the tool returns; use listProcesses to check status or the host UI (/procs, /stop) to stop it.",
+      parameters: {
+        type: "object",
+        properties: {
+          command: {
+            type: "string",
+            description: "Shell command to run in background."
+          },
+          label: {
+            type: "string",
+            description: "Optional friendly label for the process."
+          }
+        },
+        required: ["command"]
+      }
+    }
+  };
+}
+function buildListProcessesTool() {
+  return {
+    type: "function",
+    function: {
+      name: "listProcesses",
+      description: "List currently registered background processes launched via launchProcess. Returns array of {pid, label, command, status, startedAt}.",
+      parameters: {
+        type: "object",
+        properties: {}
+      }
+    }
+  };
+}
+function wrapPowerShellCommand(command) {
+  return [
+    "[Console]::InputEncoding=[System.Text.Encoding]::UTF8",
+    "[Console]::OutputEncoding=[System.Text.Encoding]::UTF8",
+    "$OutputEncoding=[System.Text.Encoding]::UTF8",
+    "$PSStyle.OutputRendering='PlainText'",
+    command
+  ].join("; ");
+}
+function findPowerShellExecutable() {
+  return resolveExecutableOnPath("pwsh") || resolveExecutableOnPath("powershell.exe") || resolveExecutableOnPath("powershell");
+}
+function buildPowerShellCommand(command) {
+  const executable = findPowerShellExecutable();
+  if (!executable) throw new Error("PowerShell is not available on this machine.");
+  return [
+    executable,
+    "-NoLogo",
+    "-NoProfile",
+    "-NonInteractive",
+    "-ExecutionPolicy",
+    "Bypass",
+    "-Command",
+    wrapPowerShellCommand(command)
+  ];
+}
+function buildBashCommand(command) {
+  const executable = resolveExecutableOnPath("bash") || resolveExecutableOnPath("sh");
+  if (!executable) throw new Error("bash/sh is not available on this machine.");
+  return [executable, "-lc", command];
+}
+function buildWorkspaceShellCommand(args) {
+  if (args.shell === "powershell") return buildPowerShellCommand(args.command);
+  if (args.shell === "bash") return buildBashCommand(args.command);
+  return process.platform === "win32" ? buildPowerShellCommand(args.command) : buildBashCommand(args.command);
+}
+function findWorkspaceShellEscapeToken(command) {
+  const tokens = tokenizeShellPrefix(command);
+  for (const token of tokens) {
+    if (token === ".." || token.startsWith("../") || token.startsWith("..\\") || token.includes("/../") || token.includes("\\..\\")) {
+      return token;
+    }
+    if (token === "~" || token.startsWith("~/") || token.startsWith("~\\")) {
+      return token;
+    }
+    if (token === "/" || token.startsWith("/") || /^[A-Za-z]:[\\/]/.test(token) || token.startsWith("\\\\")) {
+      return token;
+    }
+  }
+  return null;
+}
+function buildWorkspaceShellEscapeBlockedResult(args) {
+  return {
+    content: [
+      "workspace_shell_escape_blocked",
+      `blockedToken: ${args.token}`,
+      `command: ${args.command}`,
+      "Use paths relative to the authorized folder only.",
+      "exitCode: 126"
+    ].join("\n"),
+    metadata: {
+      exitCode: 126,
+      workspaceShellEscapeBlocked: true,
+      blockedToken: args.token
+    }
+  };
+}
+function buildWorkspaceToolDefinition(toolName, args) {
+  if (toolName === "listFiles") {
+    return buildListWorkspaceFilesTool({
+      descriptionVariant: args?.listFilesDescriptionVariant,
+      parameterVariant: args?.listFilesParameterVariant
+    });
+  }
+  if (toolName === "readFile") {
+    return buildReadWorkspaceFileTool({
+      descriptionVariant: args?.readFileDescriptionVariant,
+      parameterVariant: args?.readFileParameterVariant
+    });
+  }
+  if (toolName === "writeFile") {
+    return buildWriteWorkspaceFileTool();
+  }
+  if (toolName === "editFile") {
+    return buildReplaceWorkspaceTextTool();
+  }
+  if (toolName === "globFiles") {
+    return buildGlobWorkspaceFilesTool({
+      descriptionVariant: args?.globFilesDescriptionVariant,
+      parameterVariant: args?.globFilesParameterVariant
+    });
+  }
+  if (toolName === "searchFiles") {
+    return buildSearchWorkspaceTool({
+      descriptionVariant: args?.searchFilesDescriptionVariant,
+      parameterVariant: args?.searchFilesParameterVariant
+    });
+  }
+  if (toolName === "captureVisualState") return buildCaptureVisualStateTool();
+  if (toolName === "execShell") return buildExecShellTool(toolName);
+  if (toolName === "launchProcess") return buildLaunchProcessTool();
+  if (toolName === "listProcesses") return buildListProcessesTool();
+  return null;
+}
+function filterDeclaredWorkspaceToolNames(args) {
+  return (args.toolNames ?? []).filter(
+    (toolName) => WORKSPACE_TOOL_NAME_SET.has(toolName) && !REMOVED_WORKSPACE_TOOL_NAMES.has(toolName) && (args.exposeShellTools || !SHELL_TOOL_NAMES.includes(toolName))
+  );
+}
+
+// packages/agent-runtime/localWorkspaceTools.ts
+var EXEC_SHELL_TIMEOUT_ENV = "NOLO_EXEC_SHELL_TIMEOUT_MS";
+var EXEC_SHELL_DETACH_ENV = "NOLO_EXEC_SHELL_DETACH_MS";
+var DEFAULT_EXEC_SHELL_DETACH_MS = 12e4;
+var DEFAULT_LOCAL_API_ORIGIN = "http://127.0.0.1:38123";
+function readTrimmedString(value) {
+  return asOptionalTrimmedString(value);
+}
+function resolveExecShellTimeoutMs(override) {
+  const fromOverride = asOptionalPositiveFiniteNumber(override);
+  if (fromOverride !== void 0) return fromOverride;
+  const raw = process.env[EXEC_SHELL_TIMEOUT_ENV];
+  if (raw === void 0) return void 0;
+  return asOptionalPositiveFiniteNumber(Number(raw));
+}
+function resolveDetachMs(override) {
+  const fromOverride = asOptionalPositiveFiniteNumber(override);
+  if (fromOverride !== void 0) return fromOverride;
+  const raw = process.env[EXEC_SHELL_DETACH_ENV];
+  if (raw === void 0) return DEFAULT_EXEC_SHELL_DETACH_MS;
+  const parsed = asOptionalPositiveFiniteNumber(Number(raw));
+  return parsed === void 0 ? DEFAULT_EXEC_SHELL_DETACH_MS : parsed;
+}
+function extractInteractiveGhAuthCommand(command) {
+  const tokens = tokenizeShellPrefix(command);
+  if (tokens[0] !== "gh" || tokens[1] !== "auth") return null;
+  const subcommand = tokens[2];
+  if (subcommand !== "login" && subcommand !== "refresh") return null;
+  if (tokens.includes("--help")) return null;
+  const result = ["gh", "auth", subcommand];
+  for (let index = 3; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (!token) continue;
+    if (token === "-h" || token === "--hostname" || token === "-s" || token === "--scopes" || token === "--remove-scopes" || token === "-r") {
+      const value = tokens[index + 1];
+      if (value) {
+        result.push(token, value);
+        index += 1;
+      }
+      continue;
+    }
+    if (token === "--clipboard" || token === "-c" || token === "--insecure-storage" || token === "--reset-scopes") {
+      result.push(token);
+      continue;
+    }
+    if (token.startsWith("--hostname=") || token.startsWith("--scopes=") || token.startsWith("--remove-scopes=")) {
+      result.push(token);
+      continue;
+    }
+  }
+  return result.join(" ");
+}
+function splitShellWords(command) {
+  return tokenizeShellPrefix(command);
+}
+function buildInteractiveCommandBlockedResult(command) {
+  const argv = splitShellWords(command);
+  return {
+    content: [
+      "action_gate: handoff",
+      `command: ${command}`,
+      "Run this in the current TUI terminal, then resume the agent turn.",
+      "exitCode: 130"
+    ].join("\n"),
+    metadata: {
+      exitCode: 130,
+      timedOut: false,
+      actionGate: {
+        id: `gate-${Date.now().toString(36)}-terminal-handoff`,
+        kind: "handoff",
+        title: "This command requires an interactive terminal.",
+        body: "Complete it in the terminal, then nolo will continue.",
+        payload: {
+          command: argv,
+          displayCommand: command
+        }
+      },
+      reason: "interactive-command-requires-terminal"
+    }
+  };
+}
+function extractActivityRefs(rawRefs) {
+  if (!Array.isArray(rawRefs)) return void 0;
+  const refs = rawRefs.flatMap((entry) => {
+    if (!isRecord(entry)) return [];
+    if (entry.type === "file") {
+      const path = readTrimmedString(entry.path);
+      return path ? [{ type: "file", path }] : [];
+    }
+    if (entry.type === "terminal") {
+      const id = readTrimmedString(entry.id);
+      const label = readTrimmedString(entry.label);
+      return id || label ? [{ type: "terminal", ...id ? { id } : {}, ...label ? { label } : {} }] : [];
+    }
+    if (entry.type === "url") {
+      const url = readTrimmedString(entry.url);
+      const label = readTrimmedString(entry.label);
+      return url ? [{ type: "url", url, ...label ? { label } : {} }] : [];
+    }
+    return [];
+  });
+  return refs.length ? refs : void 0;
+}
+function extractActivityAction(rawAction) {
+  if (!isRecord(rawAction)) return void 0;
+  const title = readTrimmedString(rawAction.title);
+  if (!title) return void 0;
+  const kind = readTrimmedString(rawAction.kind);
+  const detail = readTrimmedString(rawAction.detail);
+  const refs = extractActivityRefs(rawAction.refs);
+  return {
+    title,
+    ...kind ? { kind } : {},
+    ...detail ? { detail } : {},
+    ...refs ? { refs } : {}
+  };
+}
+function extractActivityPhase(rawPhase) {
+  if (!isRecord(rawPhase)) return void 0;
+  const title = readTrimmedString(rawPhase.title);
+  if (!title) return void 0;
+  const id = readTrimmedString(rawPhase.id) || title.toLowerCase().replace(/\s+/g, "-");
+  const index = asOptionalFiniteNumber(rawPhase.index);
+  const total = asOptionalFiniteNumber(rawPhase.total);
+  const status = rawPhase.status === "pending" || rawPhase.status === "running" || rawPhase.status === "success" || rawPhase.status === "failed" ? rawPhase.status : void 0;
+  return {
+    id,
+    title,
+    ...index !== void 0 ? { index } : {},
+    ...total !== void 0 ? { total } : {},
+    ...status ? { status } : {}
+  };
+}
+function extractActivityPlan(rawPlan) {
+  if (!isRecord(rawPlan)) return void 0;
+  if (!Array.isArray(rawPlan.phases)) return void 0;
+  const phases = rawPlan.phases.flatMap((entry, index) => {
+    const phase = extractActivityPhase(entry);
+    if (!phase) return [];
+    return [{
+      id: phase.id,
+      title: phase.title,
+      index: phase.index ?? index + 1,
+      ...phase.status ? { status: phase.status } : {}
+    }];
+  });
+  if (phases.length === 0) return void 0;
+  const title = readTrimmedString(rawPlan.title);
+  return {
+    ...title ? { title } : {},
+    phases
+  };
+}
+function extractActivity(parsed) {
+  const raw = parsed._activity;
+  if (!isRecord(raw)) return void 0;
+  const nestedAction = extractActivityAction(raw.action);
+  const legacyAction = extractActivityAction(raw);
+  const action = nestedAction || legacyAction;
+  const phase = extractActivityPhase(raw.phase);
+  const plan = extractActivityPlan(raw.plan);
+  if (!action && !plan) return void 0;
+  return {
+    ...action ? action : {},
+    ...phase ? { phase } : {},
+    ...nestedAction ? { action: nestedAction } : {},
+    ...plan ? { plan } : {}
+  };
+}
+function buildLocalWorkspaceToolset(args) {
+  const exposeShellTools = args.exposeShellTools === true;
+  if (args.useDeclaredToolNamesOnly) {
+    const toolNames2 = new Set(filterDeclaredWorkspaceToolNames({
+      toolNames: args.declaredToolNames,
+      exposeShellTools
+    }));
+    return {
+      toolNames: [...toolNames2],
+      exposeShellTools
+    };
+  }
+  const toolNames = /* @__PURE__ */ new Set([
+    ...exposeShellTools ? SHELL_TOOL_NAMES : [],
+    ...filterDeclaredWorkspaceToolNames({
+      toolNames: args.declaredToolNames,
+      exposeShellTools
+    })
+  ]);
+  return {
+    toolNames: [...toolNames],
+    exposeShellTools
+  };
+}
+function buildLocalWorkspacePolicyToolNames(args) {
+  if (args.useDeclaredToolNamesOnly) {
+    return filterDeclaredWorkspaceToolNames({
+      toolNames: args.declaredToolNames,
+      exposeShellTools: args.exposeShellTools === true
+    });
+  }
+  return [.../* @__PURE__ */ new Set([
+    ...buildLocalWorkspaceToolset({
+      exposeShellTools: args.exposeShellTools
+    }).toolNames,
+    ...filterDeclaredWorkspaceToolNames({
+      toolNames: args.declaredToolNames,
+      exposeShellTools: args.exposeShellTools === true
+    })
+  ])].filter((toolName) => !REMOVED_WORKSPACE_TOOL_NAMES.has(toolName));
+}
+function buildLocalWorkspaceOpenAiTools(args) {
+  const declaredTools = new Set(args.toolNames ?? []);
+  return WORKSPACE_TOOL_NAMES.filter((toolName) => {
+    if (!declaredTools.has(toolName)) return false;
+    if (!args.exposeShellTools && SHELL_TOOL_NAMES.includes(toolName)) {
+      return false;
+    }
+    return true;
+  }).map((toolName) => buildWorkspaceToolDefinition(toolName, {
+    listFilesDescriptionVariant: args.listFilesDescriptionVariant,
+    listFilesParameterVariant: args.listFilesParameterVariant,
+    readFileDescriptionVariant: args.readFileDescriptionVariant,
+    readFileParameterVariant: args.readFileParameterVariant,
+    globFilesDescriptionVariant: args.globFilesDescriptionVariant,
+    globFilesParameterVariant: args.globFilesParameterVariant,
+    searchFilesDescriptionVariant: args.searchFilesDescriptionVariant,
+    searchFilesParameterVariant: args.searchFilesParameterVariant
+  })).filter((tool) => Boolean(tool));
+}
+function parseWorkspaceToolArguments(raw) {
+  try {
+    return asRecordOrEmpty(JSON.parse(raw || "{}"));
+  } catch {
+    return {};
+  }
+}
+function normalizeWorkspaceRelativePath(args) {
+  const relativePath = relative(args.workspaceRoot, args.targetPath);
+  return relativePath || ".";
+}
+function isPathInsideWorkspace(args) {
+  const relativePath = relative(args.workspaceRoot, args.targetPath);
+  return relativePath === "" || !relativePath.startsWith("..") && !relativePath.includes(`..${sep}`);
+}
+function requireWorkspaceToolPath(args) {
+  const requestedPath = readWorkspacePathAlias(args) ?? "";
+  if (!requestedPath) throw new Error("Workspace tool requires a non-empty path.");
+  return requestedPath;
+}
+function readWorkspacePathAlias(args) {
+  const path = args.path ?? args.file_path ?? args.filePath ?? args.filename ?? args.file;
+  return asOptionalTrimmedString(path);
+}
+function requireWorkspaceFileContent(args) {
+  if (typeof args.content !== "string") {
+    throw new Error("writeFile requires string content.");
+  }
+  return args.content;
+}
+function requireWorkspaceOldText(args) {
+  if (typeof args.oldText !== "string" || !args.oldText) {
+    throw new Error("editFile requires non-empty oldText.");
+  }
+  return args.oldText;
+}
+function requireWorkspaceNewText(args) {
+  if (typeof args.newText !== "string") {
+    throw new Error("editFile requires string newText.");
+  }
+  return args.newText;
+}
+function readExpectedReplacementCount(args) {
+  if (args.expectedReplacements === void 0) return 1;
+  const value = Number(args.expectedReplacements);
+  if (!Number.isInteger(value) || value < 1) {
+    throw new Error("editFile expectedReplacements must be a positive integer.");
+  }
+  return value;
+}
+function readPositiveIntegerArg(args) {
+  if (args.value === void 0) return void 0;
+  const value = Number(args.value);
+  if (!Number.isInteger(value) || value < 1) {
+    throw new Error(`${args.name} must be a positive integer.`);
+  }
+  return args.max ? Math.min(value, args.max) : value;
+}
+function readFileSliceArgs(args) {
+  const startLine = readPositiveIntegerArg({ value: args.startLine, name: "startLine" });
+  const endLine = readPositiveIntegerArg({ value: args.endLine, name: "endLine" });
+  const maxLines = readPositiveIntegerArg({ value: args.maxLines, name: "maxLines", max: 2e3 });
+  const tailLines = readPositiveIntegerArg({ value: args.tailLines, name: "tailLines", max: 2e3 });
+  if (tailLines !== void 0 && (startLine !== void 0 || endLine !== void 0)) {
+    throw new Error("tailLines cannot be combined with startLine or endLine.");
+  }
+  if (endLine !== void 0 && startLine !== void 0 && endLine < startLine) {
+    throw new Error("endLine must be greater than or equal to startLine.");
+  }
+  return {
+    startLine,
+    endLine,
+    maxLines,
+    tailLines
+  };
+}
+function splitTextLines(content) {
+  const lines = content.split(/\r?\n/);
+  if (lines.length > 1 && lines[lines.length - 1] === "") lines.pop();
+  return lines;
+}
+function sliceReadFileContent(args) {
+  const lines = splitTextLines(args.content);
+  const totalLines = lines.length;
+  if (args.startLine === void 0 && args.endLine === void 0 && args.maxLines === void 0 && args.tailLines === void 0) {
+    return {
+      content: args.content,
+      startLine: 1,
+      endLine: totalLines,
+      totalLines,
+      truncated: false
+    };
+  }
+  if (args.tailLines !== void 0) {
+    const startIndex2 = Math.max(0, totalLines - args.tailLines);
+    const selected2 = lines.slice(startIndex2);
+    return {
+      content: selected2.join("\n"),
+      startLine: startIndex2 + 1,
+      endLine: startIndex2 + selected2.length,
+      totalLines,
+      truncated: startIndex2 > 0
+    };
+  }
+  const startLine = args.startLine ?? 1;
+  let endLine = args.endLine ?? totalLines;
+  if (args.maxLines !== void 0) {
+    endLine = Math.min(endLine, startLine + args.maxLines - 1);
+  }
+  const startIndex = Math.min(Math.max(startLine - 1, 0), totalLines);
+  const endIndex = Math.min(Math.max(endLine, 0), totalLines);
+  const selected = lines.slice(startIndex, endIndex);
+  const effectiveEndLine = selected.length ? startIndex + selected.length : startIndex;
+  return {
+    content: selected.join("\n"),
+    startLine,
+    endLine: effectiveEndLine,
+    totalLines,
+    truncated: startLine > 1 || effectiveEndLine < totalLines
+  };
+}
+function countExactTextOccurrences(args) {
+  return args.content.split(args.oldText).length - 1;
+}
+function pluralizeReplacement(count) {
+  return count === 1 ? "replacement" : "replacements";
+}
+var EDIT_SNIPPET_MAX_LINES = 5;
+var EDIT_SNIPPET_WIDTH = 96;
+function clipEditSnippet(text) {
+  const lines = text.split(/\r?\n/).filter((line) => line.length > 0);
+  return lines.slice(0, EDIT_SNIPPET_MAX_LINES).map((line) => line.length > EDIT_SNIPPET_WIDTH ? `${line.slice(0, EDIT_SNIPPET_WIDTH)}\u2026` : line).join("\n");
+}
+function requireWorkspaceSearchQuery(args) {
+  const query = asTrimmedString(args.query);
+  if (!query) throw new Error("searchFiles requires a non-empty query.");
+  return query;
+}
+function requireWorkspaceGlobPattern(args) {
+  const pattern = asOptionalTrimmedString(args.pattern) ?? asOptionalTrimmedString(args.glob) ?? "";
+  if (!pattern) throw new Error("globFiles requires a non-empty pattern.");
+  return pattern;
+}
+function readWorkspaceMaxResults(args) {
+  if (args.maxResults === void 0) return void 0;
+  const value = Number(args.maxResults);
+  if (!Number.isInteger(value) || value < 1) {
+    throw new Error("maxResults must be a positive integer.");
+  }
+  return Math.min(value, 500);
+}
+function readWorkspaceMaxDepth(args) {
+  if (args.maxDepth === void 0) return 1;
+  const value = Number(args.maxDepth);
+  if (!Number.isInteger(value) || value < 1) {
+    throw new Error("maxDepth must be a positive integer.");
+  }
+  return Math.min(value, 10);
+}
+function readWorkspaceEntryType(args) {
+  if (args.entryType === void 0) return "all";
+  if (args.entryType === "all" || args.entryType === "files" || args.entryType === "directories") {
+    return args.entryType;
+  }
+  throw new Error("entryType must be one of all, files, or directories.");
+}
+function readWorkspaceContextLines(args) {
+  if (args.contextLines === void 0) return void 0;
+  const value = Number(args.contextLines);
+  if (!Number.isInteger(value) || value < 0) {
+    throw new Error("contextLines must be a non-negative integer.");
+  }
+  return Math.min(value, 20);
+}
+function readWorkspaceExcludeGlobs(args) {
+  if (args.exclude === void 0) return [];
+  const singleExclude = asOptionalTrimmedString(args.exclude);
+  if (singleExclude) {
+    return [singleExclude];
+  }
+  if (!Array.isArray(args.exclude)) {
+    throw new Error("exclude must be a glob string or an array of glob strings.");
+  }
+  return asTrimmedNonEmptyStringArray(args.exclude);
+}
+function requireShellCommand(args, toolName) {
+  const command = asTrimmedString(args.cmd) || asTrimmedString(args.command);
+  if (!command) throw new Error(`${toolName} requires a non-empty command.`);
+  return command;
+}
+function requireVisualWaitSelector(args) {
+  const selector = asTrimmedString(args.waitSelector);
+  if (!selector) throw new Error("captureVisualState requires a non-empty waitSelector.");
+  return selector;
+}
+function readVisualStateCaptureArgs(args) {
+  const baseUrl = asOptionalTrimmedString(args.baseUrl) ?? asOptionalTrimmedString(args.base);
+  const path = asOptionalTrimmedString(args.path) ?? "/";
+  const waitSelector = requireVisualWaitSelector(args);
+  const scrollSelector = asOptionalTrimmedString(args.scrollSelector);
+  const focusSelector = asOptionalTrimmedString(args.focusSelector);
+  const expectText = asOptionalTrimmedString(args.expectText);
+  const screenshotPath = asOptionalTrimmedString(args.screenshotPath) ?? "test-results/frontend-agent/visual-state.png";
+  const metricsPath = asOptionalTrimmedString(args.metricsPath) ?? "test-results/frontend-agent/visual-state-metrics.json";
+  return {
+    baseUrl,
+    path,
+    waitSelector,
+    scrollSelector,
+    focusSelector,
+    expectText,
+    screenshotPath,
+    metricsPath
+  };
+}
+async function readWorkspacePackageScripts(workspaceRoot) {
+  try {
+    const raw = await readFile(resolve(workspaceRoot, "package.json"), "utf8");
+    const parsed = JSON.parse(raw);
+    const scripts = parsed && typeof parsed === "object" && parsed.scripts && typeof parsed.scripts === "object" ? Object.keys(parsed.scripts).sort() : [];
+    return { scripts };
+  } catch (error) {
+    return {
+      scripts: [],
+      error: toErrorMessage(error)
+    };
+  }
+}
+function formatAvailableScripts(scripts) {
+  return scripts.length ? scripts.join(", ") : "(none)";
+}
+async function runWorkspacePackageScript(args) {
+  const script = args.script.trim();
+  if (!script) throw new Error("package script name is required.");
+  const extraArgs = args.extraArgs ?? [];
+  const packageScripts = await readWorkspacePackageScripts(args.workspaceRoot);
+  if (!packageScripts.scripts.includes(script)) {
+    return {
+      content: [
+        `script not found: ${script}`,
+        `available scripts: ${formatAvailableScripts(packageScripts.scripts)}`,
+        ...packageScripts.error ? [`package.json read error: ${packageScripts.error}`] : []
+      ].join("\n"),
+      metadata: {
+        script,
+        exitCode: 1,
+        reason: "script-not-found",
+        availableScripts: packageScripts.scripts,
+        ...packageScripts.error ? { packageJsonError: packageScripts.error } : {}
+      }
+    };
+  }
+  const result = await runWorkspaceCommand({
+    workspaceRoot: args.workspaceRoot,
+    command: ["bun", "run", script, ...extraArgs.length ? ["--", ...extraArgs] : []],
+    timeoutMs: args.commandTimeoutMs
+  });
+  return {
+    content: result.content,
+    metadata: {
+      script,
+      args: extraArgs,
+      exitCode: result.exitCode,
+      reason: result.exitCode === 0 ? "ok" : "script-failed",
+      timedOut: result.timedOut,
+      stdoutTail: result.stdout.trim().slice(-4e3),
+      stderrTail: result.stderr.trim().slice(-4e3)
+    }
+  };
+}
+function truncateToolOutput(value, limit = 2e4) {
+  if (value.length <= limit) return value;
+  const approxMarkerLen = 40;
+  if (limit <= approxMarkerLen) return value.slice(0, limit);
+  const remaining = limit - approxMarkerLen;
+  const headSize = Math.floor(remaining * 0.3);
+  const tailSize = remaining - headSize;
+  const head = value.slice(0, headSize);
+  const tail = value.slice(-tailSize);
+  const actualRemoved = value.length - headSize - tailSize;
+  return `${head}
+
+[... truncated ${actualRemoved} chars ...]
+
+${tail}`;
+}
+function parseLastJsonObject(text) {
+  const trimmed = text.trim();
+  for (let index = trimmed.lastIndexOf("{"); index >= 0; index = trimmed.lastIndexOf("{", index - 1)) {
+    try {
+      const parsed = JSON.parse(trimmed.slice(index));
+      return parsed && typeof parsed === "object" ? parsed : null;
+    } catch {
+    }
+  }
+  return null;
+}
+function readNodeStream(stream) {
+  if (!stream) return Promise.resolve("");
+  return new Promise((resolveRead, rejectRead) => {
+    const chunks = [];
+    stream.on("data", (chunk) => {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk)));
+    });
+    stream.on("error", rejectRead);
+    stream.on("end", () => resolveRead(Buffer.concat(chunks).toString("utf8")));
+  });
+}
+function waitForNodeProcessExit(proc) {
+  return new Promise((resolveExit, rejectExit) => {
+    proc.once("error", rejectExit);
+    proc.once("close", (code, signal) => {
+      if (typeof code === "number") {
+        resolveExit(code);
+        return;
+      }
+      resolveExit(signal ? 1 : 0);
+    });
+  });
+}
+function resolveRipgrepBinary(env = process.env) {
+  const fromEnv = asOptionalTrimmedString(env.NOLO_BUNDLED_RG);
+  if (fromEnv) {
+    try {
+      if (existsSync(fromEnv)) return fromEnv;
+    } catch {
+    }
+  }
+  return resolveExecutableOnPath("rg");
+}
+async function runWorkspaceCommand(args) {
+  const timeoutMs = asOptionalPositiveFiniteNumber(args.timeoutMs);
+  const detached = process.platform !== "win32";
+  const command = [
+    ...args.commandPrefix ?? [],
+    ...args.command
+  ];
+  const proc = spawnChildProcess(command[0] ?? "", command.slice(1), {
+    cwd: resolve(args.workspaceRoot),
+    stdio: [
+      args.stdin === void 0 ? "ignore" : "pipe",
+      "pipe",
+      "pipe"
+    ],
+    detached
+  });
+  if (args.stdin !== void 0 && proc.stdin) {
+    proc.stdin.write(args.stdin);
+    proc.stdin.end();
+  }
+  const exitPromise = waitForNodeProcessExit(proc);
+  const cleanupChildOnHostSignal = (signal) => {
+    if (typeof proc.pid === "number") {
+      try {
+        process.kill(-proc.pid, signal);
+      } catch {
+      }
+    }
+  };
+  if (detached) {
+    process.once("SIGHUP", cleanupChildOnHostSignal);
+    process.once("SIGTERM", cleanupChildOnHostSignal);
+    process.once("SIGINT", cleanupChildOnHostSignal);
+  }
+  const detachSignalCleanup = () => {
+    if (!detached) return;
+    process.removeListener("SIGHUP", cleanupChildOnHostSignal);
+    process.removeListener("SIGTERM", cleanupChildOnHostSignal);
+    process.removeListener("SIGINT", cleanupChildOnHostSignal);
+  };
+  exitPromise.then(detachSignalCleanup, detachSignalCleanup);
+  const stdoutPromise = readNodeStream(proc.stdout);
+  const stderrPromise = readNodeStream(proc.stderr);
+  const killChild = (signal) => {
+    if (detached && typeof proc.pid === "number") {
+      try {
+        process.kill(-proc.pid, signal);
+        return;
+      } catch {
+      }
+    }
+    try {
+      proc.kill(signal);
+    } catch {
+    }
+  };
+  let timeout;
+  let detachTimer;
+  const timeoutResult = Symbol("timeout");
+  const abortResult = Symbol("abort");
+  const detachResult = Symbol("detach");
+  let abortListener;
+  const abortPromise = args.abortSignal ? new Promise((resolveAbort) => {
+    if (args.abortSignal.aborted) {
+      resolveAbort(abortResult);
+      return;
+    }
+    abortListener = () => resolveAbort(abortResult);
+    args.abortSignal.addEventListener("abort", abortListener, { once: true });
+  }) : null;
+  const effectiveDetachMs = resolveDetachMs(args.detachMs);
+  const detachPromise = effectiveDetachMs ? new Promise((r) => {
+    detachTimer = setTimeout(() => r(detachResult), effectiveDetachMs);
+  }) : null;
+  const racers = [exitPromise];
+  if (timeoutMs) {
+    racers.push(
+      new Promise((resolveTimeout) => {
+        timeout = setTimeout(() => resolveTimeout(timeoutResult), timeoutMs);
+      })
+    );
+  }
+  if (abortPromise) racers.push(abortPromise);
+  if (detachPromise) racers.push(detachPromise);
+  const raceWinner = await Promise.race(racers);
+  if (timeout) clearTimeout(timeout);
+  if (detachTimer) clearTimeout(detachTimer);
+  if (abortListener && args.abortSignal) {
+    args.abortSignal.removeEventListener("abort", abortListener);
+  }
+  const timedOut = raceWinner === timeoutResult;
+  const aborted = raceWinner === abortResult;
+  const didDetach = raceWinner === detachResult;
+  if (timedOut || aborted) {
+    killChild("SIGTERM");
+    await Promise.race([
+      exitPromise.catch(() => 124),
+      new Promise((resolveKill) => setTimeout(resolveKill, 500))
+    ]);
+    killChild("SIGKILL");
+  }
+  if (didDetach) {
+    detachSignalCleanup();
+    const pid = typeof proc.pid === "number" ? proc.pid : 0;
+    const label = deriveLabel(args.command.join(" "));
+    const pgid = pid;
+    const registry2 = getProcessRegistry();
+    registry2.add({ pid, pgid, command: args.command.join(" "), label });
+    proc.on("close", (code) => {
+      registry2.markExited(pid, code ?? 1);
+    });
+    return {
+      stdout: "",
+      stderr: `command detached to background after ${effectiveDetachMs}ms (pid=${pid}, label=${label})
+Use listProcesses / processRegistry to inspect.`,
+      exitCode: 0,
+      timedOut: false,
+      detached: true,
+      pid,
+      label,
+      content: JSON.stringify({ detached: true, pid, label, status: "running" })
+    };
+  }
+  const [stdout, rawStderr] = await Promise.all([
+    stdoutPromise,
+    stderrPromise
+  ]);
+  const exitCode = aborted ? 130 : timedOut ? 124 : Number(raceWinner);
+  const stderr = aborted ? `${rawStderr.trim() ? `${rawStderr.trim()}
+` : ""}command aborted by signal
+` : timedOut ? `${rawStderr.trim() ? `${rawStderr.trim()}
+` : ""}command timed out after ${timeoutMs ?? "unknown"}ms
+` : rawStderr;
+  return {
+    stdout,
+    stderr,
+    exitCode,
+    timedOut,
+    aborted,
+    content: truncateToolOutput([
+      stdout.trim() ? `stdout:
+${stdout.trim()}` : "",
+      stderr.trim() ? `stderr:
+${stderr.trim()}` : "",
+      `exitCode: ${exitCode}`
+    ].filter(Boolean).join("\n\n"), args.outputLimit)
+  };
+}
+async function runWorkspaceCommandLimitedLines(args) {
+  const command = [
+    ...args.commandPrefix ?? [],
+    ...args.command
+  ];
+  const proc = spawnChildProcess(command[0] ?? "", command.slice(1), {
+    cwd: resolve(args.workspaceRoot),
+    stdio: ["ignore", "pipe", "pipe"],
+    detached: false
+  });
+  const exitSettled = waitForNodeProcessExit(proc).then(
+    (code) => ({ ok: true, code }),
+    (error) => ({ ok: false, error })
+  );
+  const stderrPromise = readNodeStream(proc.stderr);
+  const lines = [];
+  let pending = "";
+  let limitedByMaxResults = false;
+  try {
+    await Promise.race([
+      new Promise((resolveRead, rejectRead) => {
+        proc.stdout?.on("data", (chunk) => {
+          pending += Buffer.isBuffer(chunk) ? chunk.toString("utf8") : String(chunk);
+          const parts = pending.split(/\r?\n/);
+          pending = parts.pop() ?? "";
+          for (const part of parts) {
+            if (!part) continue;
+            lines.push(part);
+            if (lines.length >= args.maxLines) {
+              limitedByMaxResults = true;
+              try {
+                proc.kill("SIGTERM");
+              } catch {
+              }
+              break;
+            }
+          }
+        });
+        proc.stdout?.on("error", rejectRead);
+        proc.stdout?.on("end", () => resolveRead());
+        if (!proc.stdout) {
+          void exitSettled.then((result) => {
+            if (!result.ok) rejectRead(result.error);
+            else resolveRead();
+          });
+        }
+      }),
+      exitSettled.then((result) => {
+        if (!result.ok) throw result.error;
+      })
+    ]);
+  } catch (error) {
+    const settled2 = await exitSettled;
+    if (!settled2.ok) throw settled2.error;
+    throw error;
+  }
+  if (!limitedByMaxResults && pending.trim()) lines.push(pending);
+  const settled = await exitSettled;
+  if (!settled.ok) throw settled.error;
+  const exitCode = limitedByMaxResults ? 0 : settled.code;
+  const stderr = await stderrPromise;
+  return {
+    stdout: lines.slice(0, args.maxLines).join("\n"),
+    stderr,
+    exitCode,
+    limitedByMaxResults
+  };
+}
+async function resolveLocalWorkspaceToolPath(args) {
+  const workspaceRoot = resolve(args.workspaceRoot);
+  const targetPath = resolve(workspaceRoot, args.requestedPath);
+  if (!isPathInsideWorkspace({ workspaceRoot, targetPath })) {
+    if (args.confirmExternalFileAccess) {
+      const request = {
+        id: "permission-file-external-access",
+        tool: "fileTool",
+        action: "external_file_access",
+        title: "\u786E\u8BA4\u8BFB\u53D6\u5DE5\u4F5C\u533A\u5916\u90E8\u6587\u4EF6",
+        body: "\u8BE5\u8DEF\u5F84\u4F4D\u4E8E\u5F53\u524D\u5DE5\u4F5C\u533A\u4E4B\u5916\u3002\u786E\u8BA4\u540E\u672C\u6B21\u8BBF\u95EE\u653E\u884C\uFF0C\u5426\u5219\u62D2\u7EDD\u3002",
+        command: args.requestedPath,
+        suggestedRule: {
+          scope: "once",
+          pattern: { capability: "external_file_access", target: args.requestedPath }
+        }
+      };
+      const confirmed = await args.confirmExternalFileAccess(request);
+      if (!confirmed) {
+        const error = new Error(
+          `external file access blocked: user declined confirmation for ${args.requestedPath}`
+        );
+        error.code = "external_file_access_requires_confirmation";
+        error.permissionRequest = request;
+        throw error;
+      }
+    }
+  }
+  return targetPath;
+}
+async function readFileTool(args) {
+  const parsed = parseWorkspaceToolArguments(args.call.arguments);
+  const requestedPath = requireWorkspaceToolPath(parsed);
+  const sliceArgs = readFileSliceArgs(parsed);
+  const absolutePath = await resolveLocalWorkspaceToolPath({
+    workspaceRoot: args.workspaceRoot,
+    requestedPath,
+    ...args.confirmExternalFileAccess ? { confirmExternalFileAccess: args.confirmExternalFileAccess } : {}
+  });
+  const content = await readFile(absolutePath, "utf8");
+  const activity = extractActivity(parsed);
+  const sliced = sliceReadFileContent({
+    content,
+    ...sliceArgs
+  });
+  return {
+    content: sliced.content,
+    metadata: {
+      path: normalizeWorkspaceRelativePath({
+        workspaceRoot: resolve(args.workspaceRoot),
+        targetPath: absolutePath
+      }),
+      bytes: Buffer.byteLength(sliced.content),
+      totalBytes: Buffer.byteLength(content),
+      startLine: sliced.startLine,
+      endLine: sliced.endLine,
+      totalLines: sliced.totalLines,
+      truncated: sliced.truncated,
+      ...sliceArgs.maxLines ? { maxLines: sliceArgs.maxLines } : {},
+      ...sliceArgs.tailLines ? { tailLines: sliceArgs.tailLines } : {},
+      ...activity ? { activity } : {}
+    }
+  };
+}
+async function writeFileTool(args) {
+  const parsed = parseWorkspaceToolArguments(args.call.arguments);
+  const requestedPath = requireWorkspaceToolPath(parsed);
+  const content = requireWorkspaceFileContent(parsed);
+  const absolutePath = await resolveLocalWorkspaceToolPath({
+    workspaceRoot: args.workspaceRoot,
+    requestedPath,
+    ...args.confirmExternalFileAccess ? { confirmExternalFileAccess: args.confirmExternalFileAccess } : {}
+  });
+  await mkdir(dirname(absolutePath), { recursive: true });
+  await writeFile(absolutePath, content, "utf8");
+  const relativePath = normalizeWorkspaceRelativePath({
+    workspaceRoot: resolve(args.workspaceRoot),
+    targetPath: absolutePath
+  });
+  const activity = extractActivity(parsed);
+  let diffStat;
+  try {
+    const stats = [];
+    for (const ref of ["", "--cached"]) {
+      const result = spawnSync("git", ["diff", ref, "--stat", "--", relativePath], {
+        cwd: args.workspaceRoot,
+        timeout: 3e3,
+        encoding: "utf-8",
+        stdio: ["ignore", "pipe", "pipe"]
+      });
+      const out = (result.stdout ?? "").trim();
+      if (out) stats.push(out);
+    }
+    if (stats.length > 0) diffStat = stats.join("; ");
+  } catch (err) {
+    diffStat = `[git diff unavailable: ${toErrorMessage(err)}]`;
+  }
+  return {
+    content: `wrote ${relativePath}`,
+    metadata: {
+      path: relativePath,
+      bytes: Buffer.byteLength(content),
+      ...diffStat ? { diffStat } : {},
+      ...activity ? { activity } : {}
+    }
+  };
+}
+async function editFileTool(args) {
+  const parsed = parseWorkspaceToolArguments(args.call.arguments);
+  const requestedPath = requireWorkspaceToolPath(parsed);
+  const oldText = requireWorkspaceOldText(parsed);
+  const newText = requireWorkspaceNewText(parsed);
+  const expectedReplacements = readExpectedReplacementCount(parsed);
+  const absolutePath = await resolveLocalWorkspaceToolPath({
+    workspaceRoot: args.workspaceRoot,
+    requestedPath,
+    ...args.confirmExternalFileAccess ? { confirmExternalFileAccess: args.confirmExternalFileAccess } : {}
+  });
+  const content = await readFile(absolutePath, "utf8");
+  const replacementCount = countExactTextOccurrences({ content, oldText });
+  if (replacementCount !== expectedReplacements) {
+    throw new Error(
+      `editFile expected ${expectedReplacements} ${pluralizeReplacement(expectedReplacements)} but found ${replacementCount} in ${requestedPath}.`
+    );
+  }
+  const nextContent = content.split(oldText).join(newText);
+  await writeFile(absolutePath, nextContent, "utf8");
+  const relativePath = normalizeWorkspaceRelativePath({
+    workspaceRoot: resolve(args.workspaceRoot),
+    targetPath: absolutePath
+  });
+  const activity = extractActivity(parsed);
+  return {
+    content: `replaced ${replacementCount} occurrence${replacementCount === 1 ? "" : "s"} in ${relativePath}`,
+    metadata: {
+      path: relativePath,
+      replacements: replacementCount,
+      bytes: Buffer.byteLength(nextContent),
+      oldSnippet: clipEditSnippet(oldText),
+      newSnippet: clipEditSnippet(newText),
+      ...activity ? { activity } : {}
+    }
+  };
+}
+async function listWorkspaceEntries(args) {
+  const entries = [];
+  let truncated = false;
+  let visitedEntries = 0;
+  let limitedByMaxDepth = false;
+  const visit = async (dirPath, depth) => {
+    if (truncated) return;
+    const names = (await readdir(dirPath)).sort((left, right) => left.localeCompare(right));
+    for (const name of names) {
+      if (truncated) break;
+      const absolutePath = resolve(dirPath, name);
+      const info = await stat(absolutePath);
+      visitedEntries += 1;
+      const relativePath = normalizeWorkspaceRelativePath({
+        workspaceRoot: resolve(args.workspaceRoot),
+        targetPath: absolutePath
+      });
+      const isDirectory = info.isDirectory();
+      if (args.entryType === "all" || args.entryType === "files" && !isDirectory || args.entryType === "directories" && isDirectory) {
+        entries.push(isDirectory ? `${relativePath}/` : relativePath);
+        if (args.maxResults && entries.length >= args.maxResults) {
+          truncated = true;
+          break;
+        }
+      }
+      if (isDirectory && depth < args.maxDepth) {
+        await visit(absolutePath, depth + 1);
+      } else if (isDirectory && depth >= args.maxDepth && !limitedByMaxDepth) {
+        const childNames = await readdir(absolutePath);
+        limitedByMaxDepth = childNames.length > 0;
+      }
+    }
+  };
+  await visit(args.dirPath, 1);
+  return {
+    entries,
+    truncated,
+    visitedEntries,
+    limitedByMaxDepth
+  };
+}
+async function listFilesTool(args) {
+  const parsed = parseWorkspaceToolArguments(args.call.arguments);
+  const requestedPath = readWorkspacePathAlias(parsed) ?? ".";
+  const maxDepth = readWorkspaceMaxDepth(parsed);
+  const maxResults = readWorkspaceMaxResults(parsed);
+  const entryType = readWorkspaceEntryType(parsed);
+  const dirPath = await resolveLocalWorkspaceToolPath({
+    workspaceRoot: args.workspaceRoot,
+    requestedPath,
+    ...args.confirmExternalFileAccess ? { confirmExternalFileAccess: args.confirmExternalFileAccess } : {}
+  });
+  const listed = await listWorkspaceEntries({
+    workspaceRoot: args.workspaceRoot,
+    dirPath,
+    maxDepth,
+    maxResults,
+    entryType
+  });
+  return {
+    content: listed.entries.join("\n"),
+    metadata: {
+      path: requestedPath,
+      count: listed.entries.length,
+      maxDepth,
+      entryType,
+      truncated: listed.truncated,
+      limitedByMaxResults: listed.truncated,
+      limitedByMaxDepth: listed.limitedByMaxDepth,
+      visitedEntries: listed.visitedEntries,
+      ...maxResults ? { maxResults } : {}
+    }
+  };
+}
+async function searchFilesTool(args) {
+  const parsed = parseWorkspaceToolArguments(args.call.arguments);
+  const query = requireWorkspaceSearchQuery(parsed);
+  const exclude = readWorkspaceExcludeGlobs(parsed);
+  const maxResults = readWorkspaceMaxResults(parsed);
+  const contextLines = readWorkspaceContextLines(parsed);
+  const literal = parsed.literal === true;
+  const caseSensitive = parsed.caseSensitive === false ? false : true;
+  const requestedPath = readWorkspacePathAlias(parsed) ?? ".";
+  const includeIgnored = parsed.includeIgnored === true;
+  const searchPath = await resolveLocalWorkspaceToolPath({
+    workspaceRoot: args.workspaceRoot,
+    requestedPath,
+    ...args.confirmExternalFileAccess ? { confirmExternalFileAccess: args.confirmExternalFileAccess } : {}
+  });
+  const relativeSearchPath = normalizeWorkspaceRelativePath({
+    workspaceRoot: resolve(args.workspaceRoot),
+    targetPath: searchPath
+  });
+  const rgBinary = resolveRipgrepBinary();
+  const grepBinary = resolveExecutableOnPath("grep") || "grep";
+  const rgCommand = rgBinary ? [
+    rgBinary,
+    "--line-number",
+    "--no-heading",
+    "--hidden",
+    ...literal ? ["--fixed-strings"] : [],
+    ...caseSensitive ? [] : ["--ignore-case"],
+    ...contextLines !== void 0 ? ["--context", String(contextLines)] : [],
+    ...includeIgnored ? ["--no-ignore"] : [],
+    "--glob",
+    "!node_modules",
+    "--glob",
+    "!.git",
+    ...exclude.flatMap((excludePattern) => ["--glob", `!${excludePattern}`]),
+    "--",
+    query,
+    relativeSearchPath
+  ] : null;
+  const grepCommand = [
+    grepBinary,
+    "-R",
+    "-n",
+    "-I",
+    ...literal ? ["-F"] : [],
+    ...caseSensitive ? [] : ["-i"],
+    ...contextLines !== void 0 ? ["-C", String(contextLines)] : [],
+    "--exclude-dir=node_modules",
+    "--exclude-dir=.git",
+    ...exclude.flatMap((excludePattern) => ["--exclude", excludePattern]),
+    query,
+    relativeSearchPath
+  ];
+  const result = await (async () => {
+    if (rgCommand) {
+      try {
+        return maxResults && !contextLines ? await runWorkspaceCommandLimitedLines({
+          workspaceRoot: args.workspaceRoot,
+          command: rgCommand,
+          maxLines: maxResults
+        }) : await runWorkspaceCommand({
+          workspaceRoot: args.workspaceRoot,
+          command: rgCommand
+        });
+      } catch {
+      }
+    }
+    try {
+      return maxResults && !contextLines ? await runWorkspaceCommandLimitedLines({
+        workspaceRoot: args.workspaceRoot,
+        command: grepCommand,
+        maxLines: maxResults
+      }) : await runWorkspaceCommand({
+        workspaceRoot: args.workspaceRoot,
+        command: grepCommand
+      });
+    } catch {
+      return {
+        stdout: "",
+        stderr: "",
+        exitCode: 0,
+        limitedByMaxResults: false
+      };
+    }
+  })();
+  let outputLines = result.stdout.split(/\r?\n/).map((line) => line.trimEnd().replace(/^\.\//, "")).filter(Boolean);
+  let limitedByMaxResults = "limitedByMaxResults" in result && result.limitedByMaxResults === true;
+  if (outputLines.length === 0 && result.exitCode === 0 && (includeIgnored || !await hasRootGitignore(args.workspaceRoot))) {
+    const fallback = await scanWorkspaceTextMatches({
+      workspaceRoot: args.workspaceRoot,
+      relativeSearchPath,
+      query,
+      exclude,
+      maxResults,
+      literal,
+      caseSensitive,
+      contextLines
+    });
+    outputLines = fallback.lines;
+    limitedByMaxResults = fallback.limitedByMaxResults;
+  }
+  if (contextLines && outputLines.length > 0) {
+    const limited = limitSearchOutputByMatches(outputLines, maxResults);
+    outputLines = limited.lines;
+    limitedByMaxResults = limitedByMaxResults || limited.truncated;
+  }
+  const matchLines = outputLines.filter((line) => /:\d+:/.test(line));
+  const matchedFiles = Array.from(new Set(matchLines.flatMap((line) => {
+    const match = line.match(/^(.*?):\d+:/);
+    return match?.[1] ? [match[1]] : [];
+  })));
+  return {
+    content: outputLines.join("\n"),
+    metadata: {
+      query,
+      path: requestedPath,
+      searchedPath: relativeSearchPath,
+      exclude,
+      includeIgnored,
+      literal,
+      caseSensitive,
+      ...contextLines === void 0 ? {} : { contextLines },
+      count: outputLines.length,
+      matchCount: matchLines.length,
+      matchedFiles,
+      truncated: limitedByMaxResults,
+      limitedByMaxResults,
+      ...maxResults ? { maxResults } : {},
+      exitCode: result.exitCode,
+      ...extractActivity(parsed) ? { activity: extractActivity(parsed) } : {}
+    }
+  };
+}
+async function hasRootGitignore(workspaceRoot) {
+  try {
+    await stat(resolve(workspaceRoot, ".gitignore"));
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function readRootGitignorePatterns(workspaceRoot) {
+  try {
+    const content = await readFile(resolve(workspaceRoot, ".gitignore"), "utf8");
+    return content.split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith("#") && !line.startsWith("!")).map((line) => {
+      const unanchored = line.replace(/^\//, "");
+      return unanchored.endsWith("/") ? `${unanchored}**` : unanchored;
+    });
+  } catch {
+    return [];
+  }
+}
+async function filterRootGitignoredFiles(args) {
+  if (args.includeIgnored) return args.files;
+  const patterns = await readRootGitignorePatterns(args.workspaceRoot);
+  if (patterns.length === 0) return args.files;
+  const globs = patterns.map((pattern) => createGlob(pattern));
+  return args.files.filter((file) => !globs.some((glob) => glob.match(file)));
+}
+function scanWorkspaceGlobFiles(args) {
+  const pathPrefix = args.relativeSearchPath === "." ? "" : `${args.relativeSearchPath.replace(/\/+$/, "")}/`;
+  return Array.from(createGlob(args.pattern).scanSync({
+    cwd: args.workspaceRoot,
+    dot: true,
+    onlyFiles: true
+  })).map((line) => line.trim().replace(/^\.\//, "")).filter(Boolean).filter((line) => !line.startsWith(".git/") && !line.startsWith("node_modules/")).filter((line) => !pathPrefix || line === args.relativeSearchPath || line.startsWith(pathPrefix)).filter((line) => !args.exclude.some((pattern) => createGlob(pattern).match(line))).sort((left, right) => left.localeCompare(right));
+}
+function limitSearchOutputByMatches(lines, maxResults) {
+  if (!maxResults) return { lines, truncated: false };
+  const limited = [];
+  let matches = 0;
+  for (const line of lines) {
+    if (/:\d+:/.test(line)) {
+      if (matches >= maxResults) {
+        return { lines: limited, truncated: true };
+      }
+      matches += 1;
+    }
+    limited.push(line);
+  }
+  return { lines: limited, truncated: false };
+}
+async function scanWorkspaceTextMatches(args) {
+  const files = scanWorkspaceGlobFiles({
+    workspaceRoot: args.workspaceRoot,
+    pattern: "**/*",
+    relativeSearchPath: args.relativeSearchPath,
+    exclude: args.exclude
+  });
+  const results = [];
+  const seenContext = /* @__PURE__ */ new Set();
+  let matchCount = 0;
+  const literalQuery = args.caseSensitive ? args.query : args.query.toLowerCase();
+  const regex = args.literal ? void 0 : new RegExp(args.query, args.caseSensitive ? "" : "i");
+  const pushLine = (file, lineNumber, text, isMatch) => {
+    const separator = isMatch ? ":" : "-";
+    const key = `${file}:${lineNumber}:${separator}`;
+    if (seenContext.has(key)) return;
+    seenContext.add(key);
+    results.push(`${file}${separator}${lineNumber}${separator}${text}`);
+  };
+  for (const file of files) {
+    let content = "";
+    try {
+      content = await readFile(resolve(args.workspaceRoot, file), "utf8");
+    } catch {
+      continue;
+    }
+    if (content.includes("\0")) continue;
+    const lines = content.split(/\r?\n/);
+    for (let index = 0; index < lines.length; index += 1) {
+      const line = lines[index] ?? "";
+      const haystack = args.caseSensitive ? line : line.toLowerCase();
+      const matched = args.literal ? haystack.includes(literalQuery) : regex?.test(line) === true;
+      if (!matched) continue;
+      matchCount += 1;
+      const contextLines = args.contextLines ?? 0;
+      const start = Math.max(0, index - contextLines);
+      const end = Math.min(lines.length - 1, index + contextLines);
+      for (let contextIndex = start; contextIndex <= end; contextIndex += 1) {
+        pushLine(file, contextIndex + 1, lines[contextIndex] ?? "", contextIndex === index);
+      }
+      if (args.maxResults && matchCount >= args.maxResults) {
+        return {
+          lines: results,
+          limitedByMaxResults: true
+        };
+      }
+    }
+  }
+  return {
+    lines: results,
+    limitedByMaxResults: false
+  };
+}
+async function globFilesTool(args) {
+  const parsed = parseWorkspaceToolArguments(args.call.arguments);
+  const pattern = requireWorkspaceGlobPattern(parsed);
+  const exclude = readWorkspaceExcludeGlobs(parsed);
+  const maxResults = readWorkspaceMaxResults(parsed);
+  const requestedPath = readWorkspacePathAlias(parsed) ?? ".";
+  const includeIgnored = parsed.includeIgnored === true;
+  const searchPath = await resolveLocalWorkspaceToolPath({
+    workspaceRoot: args.workspaceRoot,
+    requestedPath,
+    ...args.confirmExternalFileAccess ? { confirmExternalFileAccess: args.confirmExternalFileAccess } : {}
+  });
+  const relativeSearchPath = normalizeWorkspaceRelativePath({
+    workspaceRoot: resolve(args.workspaceRoot),
+    targetPath: searchPath
+  });
+  const command = [
+    "rg",
+    "--files",
+    "--hidden",
+    ...includeIgnored ? ["--no-ignore"] : [],
+    "--glob",
+    pattern,
+    "--glob",
+    "!node_modules",
+    "--glob",
+    "!.git",
+    ...exclude.flatMap((excludePattern) => ["--glob", `!${excludePattern}`]),
+    ...relativeSearchPath === "." ? [] : [relativeSearchPath]
+  ];
+  const result = await runWorkspaceCommand({
+    workspaceRoot: args.workspaceRoot,
+    command
+  });
+  const pathPrefix = relativeSearchPath === "." ? "" : `${relativeSearchPath.replace(/\/+$/, "")}/`;
+  let files = result.stdout.split(/\r?\n/).map((line) => line.trim().replace(/^\.\//, "")).filter(Boolean).filter((line) => !pathPrefix || line === relativeSearchPath || line.startsWith(pathPrefix)).sort((left, right) => left.localeCompare(right));
+  files = await filterRootGitignoredFiles({
+    workspaceRoot: args.workspaceRoot,
+    files,
+    includeIgnored
+  });
+  if (files.length === 0 && (includeIgnored || !await hasRootGitignore(args.workspaceRoot))) {
+    files = scanWorkspaceGlobFiles({
+      workspaceRoot: args.workspaceRoot,
+      pattern,
+      relativeSearchPath,
+      exclude
+    });
+  }
+  const commandLimitedByMaxResults = false;
+  const totalCount = commandLimitedByMaxResults ? void 0 : files.length;
+  const limitedFiles = maxResults ? files.slice(0, maxResults) : files;
+  const limitedByMaxResults = commandLimitedByMaxResults || limitedFiles.length < (totalCount ?? limitedFiles.length);
+  const activity = extractActivity(parsed);
+  return {
+    content: limitedFiles.join("\n"),
+    metadata: {
+      pattern,
+      effectivePattern: pathPrefix ? `${pathPrefix}${pattern}` : pattern,
+      path: requestedPath,
+      searchedPath: relativeSearchPath,
+      exclude,
+      includeIgnored,
+      count: limitedFiles.length,
+      ...totalCount === void 0 ? {} : { totalCount },
+      truncated: limitedByMaxResults,
+      limitedByMaxResults,
+      ...maxResults ? { maxResults } : {},
+      exitCode: result.exitCode,
+      ...activity ? { activity } : {}
+    }
+  };
+}
+async function resolveVisualStateBaseUrl(args) {
+  if (args.explicitBaseUrl) return args.explicitBaseUrl;
+  return DEFAULT_LOCAL_API_ORIGIN;
+}
+async function captureVisualStateTool(args) {
+  const parsed = parseWorkspaceToolArguments(args.call.arguments);
+  const captureArgs = readVisualStateCaptureArgs(parsed);
+  const baseUrl = await resolveVisualStateBaseUrl({
+    explicitBaseUrl: captureArgs.baseUrl
+  });
+  const extraArgs = [
+    "--base",
+    baseUrl,
+    "--path",
+    captureArgs.path,
+    "--wait-selector",
+    captureArgs.waitSelector,
+    ...captureArgs.scrollSelector ? ["--scroll-selector", captureArgs.scrollSelector] : [],
+    ...captureArgs.focusSelector ? ["--focus-selector", captureArgs.focusSelector] : [],
+    ...captureArgs.expectText ? ["--expect-text", captureArgs.expectText] : [],
+    "--screenshot",
+    captureArgs.screenshotPath,
+    "--metrics",
+    captureArgs.metricsPath
+  ];
+  const result = await runWorkspacePackageScript({
+    workspaceRoot: args.workspaceRoot,
+    script: "probe:visual-review",
+    extraArgs,
+    commandTimeoutMs: args.commandTimeoutMs
+  });
+  const metrics = parseLastJsonObject(String(result.metadata?.stdoutTail ?? result.content));
+  return {
+    content: [
+      `pageUrl: ${typeof metrics?.pageUrl === "string" ? metrics.pageUrl : ""}`,
+      `screenshotPath: ${captureArgs.screenshotPath}`,
+      `metricsPath: ${captureArgs.metricsPath}`,
+      `waitSelector: ${captureArgs.waitSelector}`,
+      ...captureArgs.focusSelector ? [`focusSelector: ${captureArgs.focusSelector}`] : [],
+      ...captureArgs.expectText ? [`expectText: ${captureArgs.expectText}`] : [],
+      "",
+      result.content
+    ].join("\n").trim(),
+    metadata: {
+      ...result.metadata,
+      script: "probe:visual-review",
+      args: extraArgs,
+      baseUrl,
+      path: captureArgs.path,
+      waitSelector: captureArgs.waitSelector,
+      scrollSelector: captureArgs.scrollSelector,
+      focusSelector: captureArgs.focusSelector,
+      expectText: captureArgs.expectText,
+      screenshotPath: captureArgs.screenshotPath,
+      metricsPath: captureArgs.metricsPath,
+      ...metrics ?? {}
+    }
+  };
+}
+async function execShellTool(args) {
+  const parsed = parseWorkspaceToolArguments(args.call.arguments);
+  const command = requireShellCommand(parsed, args.call.name);
+  if (args.restrictToWorkspace) {
+    const escapeToken = findWorkspaceShellEscapeToken(command);
+    if (escapeToken) {
+      return buildWorkspaceShellEscapeBlockedResult({ command, token: escapeToken });
+    }
+  }
+  const interactiveAuthCommand = extractInteractiveGhAuthCommand(command);
+  if (interactiveAuthCommand) {
+    const activity2 = extractActivity(parsed);
+    const blocked = buildInteractiveCommandBlockedResult(interactiveAuthCommand);
+    return {
+      ...blocked,
+      metadata: {
+        ...blocked.metadata,
+        ...activity2 ? { activity: activity2 } : {}
+      }
+    };
+  }
+  const result = await runWorkspaceCommand({
+    workspaceRoot: args.workspaceRoot,
+    command: buildWorkspaceShellCommand({
+      toolName: args.call.name,
+      command,
+      shell: parsed.shell
+    }),
+    timeoutMs: resolveExecShellTimeoutMs(args.commandTimeoutMs),
+    outputLimit: args.commandOutputLimit,
+    commandPrefix: args.commandPrefix,
+    abortSignal: args.abortSignal,
+    detachMs: args.detachMs
+  });
+  const activity = extractActivity(parsed);
+  return {
+    content: result.content,
+    metadata: {
+      command,
+      exitCode: result.exitCode,
+      timedOut: result.timedOut,
+      ...result.aborted ? { aborted: true } : {},
+      ...result.detached ? { detached: true, pid: result.pid, label: result.label, status: "running" } : {},
+      ...activity ? { activity } : {}
+    }
+  };
+}
+function deriveLabel(command) {
+  const trimmed = command.trim();
+  if (!trimmed) return "process";
+  const tokens = trimmed.split(/\s+/);
+  const lastToken = tokens[tokens.length - 1] ?? trimmed;
+  const labelCandidate = lastToken.split(/[/\\]/).pop() || lastToken;
+  return labelCandidate || trimmed;
+}
+async function launchProcessTool(args) {
+  const parsed = parseWorkspaceToolArguments(args.call.arguments);
+  const command = requireShellCommand(parsed, args.call.name);
+  if (args.restrictToWorkspace) {
+    const escapeToken = findWorkspaceShellEscapeToken(command);
+    if (escapeToken) {
+      return buildWorkspaceShellEscapeBlockedResult({ command, token: escapeToken });
+    }
+  }
+  const labelArg = readTrimmedString(parsed.label);
+  const label = labelArg || deriveLabel(command);
+  const fullCommand = buildWorkspaceShellCommand({
+    toolName: args.call.name,
+    command,
+    shell: parsed.shell
+  });
+  const cmdArgs = [
+    ...args.commandPrefix ?? [],
+    ...fullCommand
+  ];
+  const detached = process.platform !== "win32";
+  const proc = spawnChildProcess(cmdArgs[0] ?? "", cmdArgs.slice(1), {
+    cwd: resolve(args.workspaceRoot),
+    stdio: ["ignore", "pipe", "pipe"],
+    detached
+  });
+  const pid = proc.pid;
+  if (typeof pid !== "number") {
+    return {
+      content: JSON.stringify({ error: "Failed to spawn child process" }),
+      metadata: { command, status: "failed" }
+    };
+  }
+  const pgid = detached ? pid : pid;
+  const registry2 = getProcessRegistry();
+  registry2.add({ pid, pgid, command, label });
+  const cleanupChildOnHostSignal = (signal) => {
+    try {
+      if (detached) {
+        process.kill(-pid, signal);
+      } else {
+        process.kill(pid, signal);
+      }
+    } catch {
+    }
+  };
+  if (detached) {
+    process.once("SIGHUP", cleanupChildOnHostSignal);
+    process.once("SIGTERM", cleanupChildOnHostSignal);
+    process.once("SIGINT", cleanupChildOnHostSignal);
+  }
+  proc.on("close", (code) => {
+    if (detached) {
+      process.removeListener("SIGHUP", cleanupChildOnHostSignal);
+      process.removeListener("SIGTERM", cleanupChildOnHostSignal);
+      process.removeListener("SIGINT", cleanupChildOnHostSignal);
+    }
+    registry2.markExited(pid, code ?? 1);
+  });
+  const activity = extractActivity(parsed);
+  const resultData = { pid, label, status: "running" };
+  return {
+    content: JSON.stringify(resultData),
+    metadata: {
+      command,
+      pid,
+      label,
+      status: "running",
+      processLaunch: resultData,
+      ...activity ? { activity } : {}
+    }
+  };
+}
+async function listProcessesTool(args) {
+  const list = getProcessRegistry().list();
+  return {
+    content: JSON.stringify(list),
+    metadata: {
+      count: list.length,
+      processes: list
+    }
+  };
+}
+function createLocalWorkspaceToolExecutors(args) {
+  const fileAccess = args.confirmExternalFileAccess ? { confirmExternalFileAccess: args.confirmExternalFileAccess } : {};
+  return {
+    editFile: (call) => editFileTool({
+      call,
+      workspaceRoot: args.workspaceRoot,
+      ...fileAccess
+    }),
+    globFiles: (call) => globFilesTool({
+      call,
+      workspaceRoot: args.workspaceRoot,
+      ...fileAccess
+    }),
+    listFiles: (call) => listFilesTool({
+      call,
+      workspaceRoot: args.workspaceRoot,
+      ...fileAccess
+    }),
+    readFile: (call) => readFileTool({
+      call,
+      workspaceRoot: args.workspaceRoot,
+      ...fileAccess
+    }),
+    writeFile: (call) => writeFileTool({
+      call,
+      workspaceRoot: args.workspaceRoot,
+      ...fileAccess
+    }),
+    searchFiles: (call) => searchFilesTool({
+      call,
+      workspaceRoot: args.workspaceRoot,
+      ...fileAccess
+    }),
+    captureVisualState: (call) => captureVisualStateTool({
+      call,
+      workspaceRoot: args.workspaceRoot,
+      commandTimeoutMs: args.commandTimeoutMs
+    }),
+    execShell: (call, opts) => execShellTool({
+      call,
+      workspaceRoot: args.workspaceRoot,
+      commandTimeoutMs: args.commandTimeoutMs,
+      commandOutputLimit: args.commandOutputLimit,
+      commandPrefix: args.commandPrefix,
+      restrictToWorkspace: args.restrictShellToWorkspace,
+      abortSignal: opts?.abortSignal ?? args.abortSignal,
+      detachMs: opts?.detachMs ?? args.detachMs
+    }),
+    launchProcess: (call) => launchProcessTool({
+      call,
+      workspaceRoot: args.workspaceRoot,
+      commandPrefix: args.commandPrefix,
+      restrictToWorkspace: args.restrictShellToWorkspace
+    }),
+    listProcesses: (call) => listProcessesTool({
+      call
+    })
+  };
+}
+
+export {
+  parseSseDataLineJson,
+  buildOpenAiCompatibleChatCompletionRequest,
+  parseOpenAiCompatibleChatCompletionResponse,
+  readOpenAiCompatibleSseCompletion,
+  executeOpenAiCompatibleChatCompletion,
+  resolveOpenAiCompatibleProviderConfig,
+  buildAgentRuntimeAgentLookupKeys,
+  shouldFetchAgentRuntimeRecordRemotely,
+  dialogMessageRecordToAgentRuntimeMessage,
+  buildAgentRuntimeDialogWritePlan,
+  shouldCacheHybridRemoteRecord,
+  createHybridRecordStore,
+  isDestructiveShellCommand,
+  evaluateShellCommandPolicy,
+  resolveLocalToolPolicy,
+  executeLocalToolWithPolicy,
+  getProcessRegistry,
+  buildLocalWorkspaceToolset,
+  buildLocalWorkspacePolicyToolNames,
+  buildLocalWorkspaceOpenAiTools,
+  createLocalWorkspaceToolExecutors
+};