@corenel/term 0.1.0 → 0.2.1

package/dist/chunk-HYWLODZT.js

@@ -1,1230 +0,0 @@
-import {
-  emptyState
-} from "./chunk-47IH6X5H.js";
-import {
-  parseCommand
-} from "./chunk-R6AXTD55.js";
-import {
-  capPreview,
-  describeToolCall,
-  formatTools
-} from "./chunk-TCVDVYMF.js";
-import {
-  committedFromMessages,
-  titleFrom
-} from "./chunk-HAQGHLW6.js";
-
-// ../harness/providers/gateway.ts
-import OpenAI from "openai";
-
-// ../harness/log.ts
-var enabled = true;
-function setAgentLogging(on) {
-  enabled = on;
-  if (on) console.log("[agent] logging enabled");
-}
-function alog(...args) {
-  if (enabled) console.debug("[agent]", ...args);
-}
-if (typeof window !== "undefined") {
-  window.setAgentLogging = setAgentLogging;
-}
-
-// ../harness/providers/gateway.ts
-function usageFromChunk(u) {
-  const cached = u.prompt_tokens_details?.cached_tokens;
-  const out = { promptTokens: u.prompt_tokens || 0, completionTokens: u.completion_tokens || 0 };
-  if (typeof cached === "number") out.cachedTokens = cached;
-  return out;
-}
-async function streamCompletion(client, params, signal, onText) {
-  alog("stream:create", { model: params.model, messages: params.messages.length, tools: params.tools?.length ?? 0 });
-  let stream;
-  try {
-    stream = await client.chat.completions.create(
-      {
-        model: params.model,
-        messages: params.messages,
-        tools: params.tools,
-        tool_choice: params.tool_choice,
-        // Undefined is dropped by the SDK's JSON serialization, so an unset cap
-        // leaves output unbounded (unchanged behavior).
-        max_completion_tokens: params.max_completion_tokens,
-        // Undefined is dropped by the SDK, so an unset temperature leaves the
-        // provider default in place (unchanged behavior).
-        temperature: params.temperature,
-        stream: true,
-        stream_options: { include_usage: true }
-      },
-      // The agent loop (loop.ts) is the SOLE retry authority — it owns the bounded
-      // backoff retry for transient failures. Disable the OpenAI SDK's own retries
-      // (default 2) so they don't MULTIPLY with the loop's: a gateway timeout was
-      // being retried SDK(1+2) x loop(1+3) = ~12 times, turning one 300s timeout
-      // into ~12 minutes of dead attempts.
-      { signal, maxRetries: 0 }
-    );
-  } catch (e) {
-    const err = e;
-    const raw = err?.error;
-    const detail = (typeof raw === "string" ? raw : raw?.error || raw?.message) || err?.message || String(e);
-    const msg = typeof err?.status === "number" ? `Gateway ${err.status}: ${detail}` : detail;
-    alog("stream:create-error", msg);
-    throw new Error(msg);
-  }
-  alog("stream:open");
-  let content = "";
-  let finishReason = "stop";
-  let chunkN = 0;
-  const usage = { promptTokens: 0, completionTokens: 0 };
-  const byIndex = /* @__PURE__ */ new Map();
-  for await (const chunk of stream) {
-    if (chunkN++ === 0) alog("stream:first-chunk");
-    const choice = chunk.choices?.[0];
-    if (choice?.delta?.content) {
-      content += choice.delta.content;
-      onText?.(choice.delta.content);
-    }
-    for (const tc of choice?.delta?.tool_calls ?? []) {
-      const cur = byIndex.get(tc.index) ?? { id: "", name: "", arguments: "" };
-      if (tc.id) cur.id = tc.id;
-      if (tc.function?.name) cur.name = tc.function.name;
-      if (tc.function?.arguments) cur.arguments += tc.function.arguments;
-      byIndex.set(tc.index, cur);
-    }
-    if (choice?.finish_reason) finishReason = choice.finish_reason;
-    if (chunk.usage) {
-      const u = usageFromChunk(chunk.usage);
-      usage.promptTokens = u.promptTokens;
-      usage.completionTokens = u.completionTokens;
-      if (u.cachedTokens != null) usage.cachedTokens = u.cachedTokens;
-    }
-  }
-  const toolCalls = [...byIndex.entries()].sort((a, b) => a[0] - b[0]).map(([, v]) => v);
-  alog("stream:end", { chunks: chunkN, contentLen: content.length, toolCalls: toolCalls.length, finishReason, usage });
-  return { content, toolCalls, usage, finishReason };
-}
-
-// ../harness/core/recovery.ts
-var DEFAULT_RECOVERY = {
-  maxStreamRetries: 3,
-  maxToolRetries: 2,
-  baseDelayMs: 500,
-  maxDelayMs: 8e3
-};
-function resolveRecovery(cfg) {
-  return cfg ? { ...DEFAULT_RECOVERY, ...cfg } : DEFAULT_RECOVERY;
-}
-var TRANSIENT_STATUS = /* @__PURE__ */ new Set([408, 409, 425, 429, 500, 502, 503, 504]);
-var FATAL_STATUS = /* @__PURE__ */ new Set([400, 401, 403, 404, 405, 422]);
-function statusOf(message) {
-  const m = message.match(/\b(?:gateway|http|status)\b[\s:]*?(\d{3})\b/i);
-  return m ? Number(m[1]) : null;
-}
-function classifyStreamError(message, status) {
-  if (/\baborted\b|AbortError/i.test(message)) return "fatal";
-  if (/\b(timed out|request timeout|gateway timeout|deadline exceeded)\b/i.test(message)) return "fatal";
-  const code = status ?? statusOf(message);
-  if (code != null) {
-    if (FATAL_STATUS.has(code)) return "fatal";
-    if (TRANSIENT_STATUS.has(code)) return "transient";
-  }
-  if (/\b(invalid[\s_-]?api[\s_-]?key|incorrect api key|unauthorized|forbidden|quota exceeded|insufficient)\b/i.test(message)) return "fatal";
-  return "transient";
-}
-function abortableSleep(ms, signal) {
-  if (signal?.aborted) return Promise.resolve(false);
-  return new Promise((resolve) => {
-    const onAbort = () => {
-      clearTimeout(t);
-      resolve(false);
-    };
-    const t = setTimeout(() => {
-      signal?.removeEventListener("abort", onAbort);
-      resolve(true);
-    }, ms);
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
-}
-function classifyToolError(message) {
-  if (/\b(invalid|malformed|required|must be|expected|not valid json|missing|unrecognized|schema|parameter)\b/i.test(message)) return "bad-args";
-  return "tool-failure";
-}
-function shouldRetryStream(kind, attempt, cfg) {
-  return kind === "transient" && attempt <= cfg.maxStreamRetries;
-}
-function backoffDelay(cfg, attempt) {
-  const exp = cfg.baseDelayMs * 2 ** Math.max(0, attempt - 1);
-  return Math.min(cfg.maxDelayMs, exp);
-}
-function toolRecoveryHint(tool, kind, message, attempt, cfg) {
-  const head = `Error from ${tool}: ${message}`;
-  if (attempt > cfg.maxToolRetries) {
-    return `${head}
-This tool has now failed ${attempt} times the same way. Do NOT call ${tool} again with these arguments \u2014 use a different tool, change your approach, or continue without it.`;
-  }
-  if (kind === "bad-args") {
-    return `${head}
-The arguments appear invalid. Re-read ${tool}'s parameter schema and call it again with corrected arguments.`;
-  }
-  return `${head}
-This may be recoverable. Reconsider your inputs or try an alternative before calling ${tool} again.`;
-}
-var ToolFailureTracker = class {
-  fails = /* @__PURE__ */ new Map();
-  /** Record a failure; returns the running same-kind attempt count (1-based). A
-   * different failure kind resets the counter for that tool. */
-  fail(tool, kind) {
-    const prev = this.fails.get(tool);
-    const count = prev && prev.kind === kind ? prev.count + 1 : 1;
-    this.fails.set(tool, { kind, count });
-    return count;
-  }
-  /** Clear a tool's failure streak; returns the streak it cleared (kind + count)
-   * so a recovery can be recorded with the RIGHT kind/attempt, or null if there
-   * was none. */
-  succeed(tool) {
-    const prev = this.fails.get(tool);
-    if (!prev) return null;
-    this.fails.delete(tool);
-    return prev;
-  }
-};
-
-// ../harness/guardrail/glob.ts
-function globToRegex(glob) {
-  let src = "";
-  for (let i = 0; i < glob.length; i++) {
-    const c = glob[i];
-    if (c === "*") {
-      if (glob[i + 1] === "*") {
-        src += ".*";
-        i++;
-      } else {
-        src += "[^.]*";
-      }
-    } else if (c === "?") {
-      src += "[^.]";
-    } else if (".+^$()[]{}|\\".includes(c)) {
-      src += "\\" + c;
-    } else {
-      src += c;
-    }
-  }
-  return new RegExp(`^${src}$`);
-}
-function matchesAnyGlob(name, globs) {
-  return globs.some((g) => globToRegex(g).test(name));
-}
-
-// ../harness/guardrail/guardrail.ts
-function callMatches(call, globs) {
-  if (!globs.length) return false;
-  if (call.address && matchesAnyGlob(call.address, globs)) return true;
-  return matchesAnyGlob(call.name, globs);
-}
-function initialState() {
-  return { turn: 0, toolCalls: 0, calledTools: /* @__PURE__ */ new Set() };
-}
-function onViolation(policy) {
-  return policy.onViolation ?? "stop";
-}
-function violate(kind, message, action, tool) {
-  const violation = tool ? { kind, message, tool } : { kind, message };
-  return { ok: false, violation, action };
-}
-function evaluateTurnStart(policy, state) {
-  if (policy.maxTurns !== void 0 && state.turn >= policy.maxTurns) {
-    return violate("MAX_TURNS", `Exceeded maxTurns=${policy.maxTurns}`, onViolation(policy));
-  }
-  return { ok: true };
-}
-function evaluateToolCall(policy, state, call) {
-  if (!call.exists) {
-    return violate("UNKNOWN_TOOL", `Model invoked unknown tool: ${call.name}`, "stop", call.name);
-  }
-  const allow = policy.tools?.allow ?? [];
-  const deny = policy.tools?.deny ?? [];
-  if (deny.length && callMatches(call, deny)) {
-    return violate("TOOL_DENIED", `Tool denied by policy: ${call.name}`, onViolation(policy), call.name);
-  }
-  if (allow.length && !callMatches(call, allow)) {
-    return violate("TOOL_NOT_ALLOWED", `Tool not in allow list: ${call.name}`, onViolation(policy), call.name);
-  }
-  if (policy.maxToolCalls !== void 0 && state.toolCalls + 1 > policy.maxToolCalls) {
-    return violate("MAX_TOOL_CALLS", `Exceeded maxToolCalls=${policy.maxToolCalls}`, onViolation(policy), call.name);
-  }
-  return { ok: true };
-}
-function evaluateCompletion(policy, state) {
-  const mustCall = policy.mustCall ?? [];
-  const missing = mustCall.filter((name) => !matchesAnyGlob2(name, state.calledTools));
-  if (!missing.length) return [];
-  return [{ kind: "MUST_CALL_MISSING", message: `Required tools were not invoked: ${missing.join(", ")}` }];
-}
-function matchesAnyGlob2(globOrName, called) {
-  for (const name of called) if (matchesAnyGlob(name, [globOrName])) return true;
-  return false;
-}
-
-// ../harness/guards.ts
-var ALLOWED = { allowed: true };
-var guards = [];
-async function checkFeature(feature) {
-  for (const g of [...guards]) {
-    if (!g.appliesTo(feature)) continue;
-    const v = await g.check(feature);
-    if (!v.allowed) return v;
-  }
-  return ALLOWED;
-}
-
-// ../harness/guardrail/builtins.ts
-var STANDARD_POLICY = {
-  version: 1,
-  name: "standard",
-  description: "Read-only tools run automatically; writes ask for approval.",
-  onViolation: "stop",
-  maxTurns: 8,
-  permissions: {
-    "prompd:propose_edit": "allow",
-    // proposals are reviewed in the diff UI, not applied directly
-    "system:*": "deny"
-    // harness self-configuration is never automatic
-  }
-  // defaultPermission omitted -> the mutates heuristic (reads allow, writes ask)
-};
-
-// ../harness/tools/namespaces.ts
-var BUILTIN_NAMESPACES = {
-  list_files: "fs",
-  read_file: "fs",
-  stat_file: "fs",
-  search_files: "fs",
-  write_file: "fs",
-  create_file: "fs",
-  delete_file: "fs",
-  rename_file: "fs",
-  compile_prompd: "prompd",
-  propose_edit: "prompd",
-  search_packages: "prompd",
-  web_search: "web",
-  save_memory: "memory",
-  recall_memory: "memory",
-  recall_result: "memory",
-  kv_get: "memory",
-  kv_set: "memory",
-  search_sessions: "memory",
-  ask_user: "agent",
-  spawn_agent: "agent",
-  spawn_agents: "agent",
-  todo_write: "agent",
-  // Named here as a backstop; the sidecar's own decls also carry `namespace`,
-  // and an explicit field always wins (resolveNamespace). Both say the same
-  // thing so a sidecar that predates this still lands in the right namespace.
-  sidecar_fs_read_file: "sidecar",
-  sidecar_fs_write_file: "sidecar",
-  sidecar_fs_read_bytes: "sidecar",
-  sidecar_fs_list_dir: "sidecar",
-  sidecar_fs_delete: "sidecar",
-  sidecar_shell_exec: "sidecar",
-  // Host-side orchestration tools. They are not in allTools() - they reach the
-  // agent as remote decls (workerFactory) - but they are still governed by the
-  // policy, so they need a canonical address like everything else.
-  create_strategy: "agent",
-  edit_strategy: "agent",
-  view_strategy: "agent",
-  run_strategy: "agent",
-  list_strategies: "agent",
-  list_saved_strategies: "agent"
-};
-function resolveNamespace(tool) {
-  if (tool.namespace) return tool.namespace;
-  const known = BUILTIN_NAMESPACES[tool.name];
-  if (known) return known;
-  const i = tool.name.indexOf("__");
-  if (i > 0) {
-    const head = tool.name.slice(0, i);
-    if (head === "mcp" || head === "skill") return head;
-  }
-  return "other";
-}
-function toolAddress(tool) {
-  const ns = resolveNamespace(tool);
-  let leaf = tool.name;
-  if (ns === "mcp" || ns === "skill") {
-    const m = new RegExp(`^${ns}__?`).exec(leaf);
-    if (m) leaf = leaf.slice(m[0].length);
-  }
-  if (ns === "sidecar") {
-    for (const p of ["sidecar_fs_", "sidecar_"]) {
-      if (leaf.startsWith(p)) {
-        leaf = leaf.slice(p.length);
-        break;
-      }
-    }
-  }
-  return `${ns}:${leaf}`;
-}
-
-// ../harness/compression.ts
-var BASE = { off: Infinity, conservative: 24e3, balanced: 12e3, aggressive: 6e3 };
-var FLOOR = { off: Infinity, conservative: 8e3, balanced: 4e3, aggressive: 2e3 };
-function effectiveThreshold(mode, fill = 0) {
-  if (mode === "off") return Infinity;
-  const factor = fill < 0.5 ? 1 : fill < 0.7 ? 0.7 : fill < 0.85 ? 0.5 : 0.35;
-  return Math.max(FLOOR[mode], Math.round(BASE[mode] * factor));
-}
-function formatOffloadRef(ref) {
-  const head = `[offloaded tool result \xB7 ${ref.toolName} \xB7 ${ref.bytes.toLocaleString()} bytes \xB7 recall the full content with recall_result({ id: "${ref.id}" })]`;
-  return ref.preview ? `${head}
---- preview ---
-${ref.preview}${ref.bytes > ref.preview.length ? "\n\u2026(truncated)" : ""}` : head;
-}
-
-// ../harness/prompts/toolsMarker.ts
-var TOOLS_MARKER = "\uE000PROMPD_TOOLS\uE000";
-function formatToolLines(tools) {
-  return tools.map((t) => `- \`${t.name}\`: ${t.description}`).join("\n");
-}
-function fillToolsMarker(system, tools) {
-  if (!system.includes(TOOLS_MARKER)) return system;
-  return system.replaceAll(TOOLS_MARKER, tools.length ? formatToolLines(tools) : "(no tools available this run)");
-}
-
-// ../harness/core/loop.ts
-async function runAgent(args) {
-  const { client, system, tools, toolCtx } = args;
-  const policy = args.policy ?? STANDARD_POLICY;
-  const permission = args.permission;
-  const compression = args.compression;
-  const ctxWindow = compression?.contextWindow;
-  let fill = 0;
-  const maxTurns = policy.maxTurns ?? args.maxTurns ?? 8;
-  const signal = args.signal ?? new AbortController().signal;
-  const emit = (e) => args.onEvent?.(e);
-  const gstate = initialState();
-  const recovery = resolveRecovery(args.recovery);
-  const toolFails = new ToolFailureTracker();
-  const messages = [...args.messages];
-  const filledSystem = system ? fillToolsMarker(system, tools) : system;
-  if (filledSystem && !messages.some((m) => m.role === "system")) {
-    messages.unshift({ role: "system", content: filledSystem });
-  }
-  const toolDefs = tools.map((t) => ({
-    type: "function",
-    function: { name: t.name, description: t.description, parameters: t.parameters }
-  }));
-  const toolByName = new Map(tools.map((t) => [t.name, t]));
-  const usage = { promptTokens: 0, completionTokens: 0 };
-  let text = "";
-  let stopReason = "stop";
-  let lastToolSig = null;
-  let lastStreamErr = "";
-  for (let turn = 1; turn <= maxTurns; turn++) {
-    if (signal.aborted) {
-      stopReason = "aborted";
-      break;
-    }
-    emit({ type: "turn", turn });
-    gstate.turn = turn - 1;
-    const turnGate = evaluateTurnStart(policy, gstate);
-    if (!turnGate.ok) {
-      emit({ type: "policy-violation", kind: turnGate.violation.kind, message: turnGate.violation.message, action: turnGate.action, tool: turnGate.violation.tool });
-      if (turnGate.action === "stop") {
-        stopReason = "policy";
-        break;
-      }
-    }
-    let streamed;
-    let streamFail = null;
-    const model = args.getModel?.() ?? args.model;
-    for (let sAttempt = 0; ; ) {
-      try {
-        const result = await streamCompletion(
-          client,
-          {
-            model,
-            messages,
-            tools: toolDefs.length ? toolDefs : void 0,
-            tool_choice: toolDefs.length ? "auto" : void 0,
-            max_completion_tokens: args.maxCompletionTokens,
-            temperature: args.temperature
-          },
-          signal,
-          (delta) => emit({ type: "assistant-delta", delta })
-        );
-        if (sAttempt > 0) emit({ type: "heal", record: { site: "stream", kind: "transient", strategy: "retry-backoff", attempt: sAttempt, outcome: "recovered", error: lastStreamErr } });
-        streamed = result;
-        break;
-      } catch (e) {
-        if (signal.aborted || e?.name === "AbortError") {
-          streamFail = "aborted";
-          break;
-        }
-        const msg = String(e?.message || e);
-        lastStreamErr = msg;
-        const kind = classifyStreamError(msg);
-        sAttempt++;
-        if (shouldRetryStream(kind, sAttempt, recovery)) {
-          emit({ type: "heal", record: { site: "stream", kind, strategy: "retry-backoff", attempt: sAttempt, outcome: "retrying", error: msg } });
-          if (!await abortableSleep(backoffDelay(recovery, sAttempt), signal)) {
-            emit({ type: "heal", record: { site: "stream", kind, strategy: "give-up", attempt: sAttempt, outcome: "abandoned", error: msg } });
-            streamFail = "aborted";
-            break;
-          }
-          continue;
-        }
-        emit({ type: "heal", record: { site: "stream", kind, strategy: "give-up", attempt: sAttempt, outcome: kind === "fatal" ? "abandoned" : "exhausted", error: msg } });
-        emit({ type: "error", message: msg });
-        streamFail = "error";
-        break;
-      }
-    }
-    if (streamFail) {
-      stopReason = streamFail;
-      break;
-    }
-    if (!streamed) {
-      stopReason = "error";
-      break;
-    }
-    usage.promptTokens += streamed.usage.promptTokens;
-    usage.completionTokens += streamed.usage.completionTokens;
-    if (ctxWindow && ctxWindow > 0 && streamed.usage.promptTokens) {
-      fill = Math.min(1, streamed.usage.promptTokens / ctxWindow);
-    }
-    emit({ type: "usage", usage: streamed.usage });
-    const assistantMsg = streamed.toolCalls.length ? {
-      role: "assistant",
-      content: streamed.content || null,
-      tool_calls: streamed.toolCalls.map((t) => ({
-        id: t.id,
-        type: "function",
-        function: { name: t.name, arguments: t.arguments }
-      }))
-    } : { role: "assistant", content: streamed.content };
-    messages.push(assistantMsg);
-    if (streamed.content) {
-      text = streamed.content;
-      emit({ type: "assistant", content: streamed.content });
-    }
-    if (streamed.toolCalls.length === 0) {
-      stopReason = streamed.finishReason || "stop";
-      break;
-    }
-    const sig = JSON.stringify(streamed.toolCalls.map((t) => ({ n: t.name, a: t.arguments })));
-    if (sig === lastToolSig) {
-      emit({ type: "error", message: "Stopped: the model repeated the same tool call without making progress." });
-      stopReason = "stuck";
-      break;
-    }
-    lastToolSig = sig;
-    let policyStop = false;
-    for (const call of streamed.toolCalls) {
-      let parsed = {};
-      try {
-        parsed = call.arguments ? JSON.parse(call.arguments) : {};
-      } catch {
-        messages.push({ role: "tool", tool_call_id: call.id, content: `Error: arguments were not valid JSON: ${call.arguments}` });
-        emit({ type: "tool-result", id: call.id, name: call.name, result: "invalid JSON arguments", isError: true });
-        continue;
-      }
-      alog("tool", call.name, parsed);
-      emit({ type: "tool-call", id: call.id, name: call.name, args: parsed });
-      const tool = toolByName.get(call.name);
-      if (!tool) {
-        messages.push({ role: "tool", tool_call_id: call.id, content: `Error: unknown tool "${call.name}"` });
-        emit({ type: "tool-result", id: call.id, name: call.name, result: "unknown tool", isError: true });
-        continue;
-      }
-      const address = toolAddress(tool);
-      const gate = evaluateToolCall(policy, gstate, { name: call.name, exists: true, address });
-      if (!gate.ok) {
-        const msg = `Blocked by policy "${policy.name}": ${gate.violation.message}`;
-        messages.push({ role: "tool", tool_call_id: call.id, content: `Error: ${msg}` });
-        emit({ type: "policy-violation", kind: gate.violation.kind, message: gate.violation.message, action: gate.action, tool: call.name });
-        emit({ type: "tool-result", id: call.id, name: call.name, result: msg, isError: true });
-        if (gate.action === "stop") {
-          policyStop = true;
-          break;
-        }
-        continue;
-      }
-      if (tool.requiresFeature) {
-        const verdict = await checkFeature(tool.requiresFeature);
-        if (!verdict.allowed) {
-          const msg = `Feature unavailable (${tool.requiresFeature}): ${verdict.reason}`;
-          messages.push({ role: "tool", tool_call_id: call.id, content: `Error: ${msg}` });
-          emit({ type: "tool-result", id: call.id, name: tool.name, result: msg, isError: true });
-          continue;
-        }
-      }
-      if (permission) {
-        const decision = await permission.check({ name: tool.name, address, mutates: tool.mutates, permission: tool.permission }, parsed);
-        emit({ type: "permission", tool: tool.name, decision });
-        if (decision === "deny") {
-          messages.push({ role: "tool", tool_call_id: call.id, content: "Permission denied by the user \u2014 the action was not performed." });
-          emit({ type: "tool-result", id: call.id, name: tool.name, result: "permission denied", isError: true });
-          continue;
-        }
-      }
-      const startedAt = Date.now();
-      try {
-        const result = await tool.run(parsed, { ...toolCtx, callId: call.id });
-        const durationMs = Date.now() - startedAt;
-        gstate.toolCalls++;
-        gstate.calledTools.add(tool.name);
-        gstate.calledTools.add(address);
-        const recovered = toolFails.succeed(tool.name);
-        if (recovered) {
-          emit({ type: "heal", record: { site: "tool", tool: tool.name, kind: recovered.kind, strategy: "steer", attempt: recovered.count, outcome: "recovered", error: "" } });
-        }
-        let out = result;
-        if (compression && compression.mode !== "off" && !tool.noOffload && toolCtx.recall) {
-          if (result.length > effectiveThreshold(compression.mode, fill)) {
-            try {
-              const ref = await toolCtx.recall.record(tool.name, result);
-              out = formatOffloadRef(ref);
-              emit({ type: "offload", id: ref.id, name: tool.name, bytes: ref.bytes });
-            } catch {
-              out = result;
-            }
-          }
-        }
-        messages.push({ role: "tool", tool_call_id: call.id, content: out });
-        emit({ type: "tool-result", id: call.id, name: call.name, result: out, durationMs });
-      } catch (e) {
-        const errMsg = String(e?.message || e);
-        const kind = classifyToolError(errMsg);
-        const attempt = toolFails.fail(tool.name, kind);
-        const exhausted = attempt > recovery.maxToolRetries;
-        emit({ type: "heal", record: { site: "tool", tool: tool.name, kind, strategy: exhausted ? "give-up" : "steer", attempt, outcome: exhausted ? "exhausted" : "retrying", error: errMsg } });
-        messages.push({ role: "tool", tool_call_id: call.id, content: toolRecoveryHint(tool.name, kind, errMsg, attempt, recovery) });
-        emit({ type: "tool-result", id: call.id, name: call.name, result: errMsg, isError: true, durationMs: Date.now() - startedAt });
-      }
-    }
-    if (policyStop) {
-      stopReason = "policy";
-      break;
-    }
-    if (turn === maxTurns) stopReason = "max_turns";
-  }
-  reconcileDanglingToolCalls(messages);
-  for (const v of evaluateCompletion(policy, gstate)) {
-    emit({ type: "policy-violation", kind: v.kind, message: v.message, action: "stop", tool: v.tool });
-  }
-  alog("done", stopReason, "tokens", usage);
-  emit({ type: "done", reason: stopReason });
-  return { messages, text, usage, stopReason };
-}
-function reconcileDanglingToolCalls(messages) {
-  let idx = -1;
-  for (let i = messages.length - 1; i >= 0; i--) {
-    const m = messages[i];
-    if (m.role === "assistant" && m.tool_calls && m.tool_calls.length) {
-      idx = i;
-      break;
-    }
-  }
-  if (idx < 0) return;
-  const asst = messages[idx];
-  if (asst.role !== "assistant" || !asst.tool_calls) return;
-  const answered = /* @__PURE__ */ new Set();
-  for (let i = idx + 1; i < messages.length; i++) {
-    const m = messages[i];
-    if (m.role === "tool") answered.add(m.tool_call_id);
-  }
-  for (const c of asst.tool_calls) {
-    if (!answered.has(c.id)) {
-      messages.push({ role: "tool", tool_call_id: c.id, content: "Tool not run \u2014 the run stopped before this call." });
-    }
-  }
-}
-
-// src/markdown.ts
-var FENCE = /^```(\w*)\s*$/;
-var HEADING = /^(#{1,6})\s+(.*)$/;
-var BULLET = /^\s*[-*]\s+(.*)$/;
-var NUMBERED = /^\s*\d+[.)]\s+(.*)$/;
-function parseMarkdown(text) {
-  return parseMarkdownSpans(text).map((s) => s.block);
-}
-function parseMarkdownSpans(text) {
-  const out = [];
-  const lines = text.split(/\r?\n/);
-  let fence = null;
-  for (const line of lines) {
-    const f = FENCE.exec(line);
-    if (fence) {
-      if (f) {
-        fence.raw.push(line);
-        out.push({ block: { kind: "code", lang: fence.lang, text: fence.body.join("\n") }, raw: fence.raw.join("\n") });
-        fence = null;
-      } else {
-        fence.body.push(line);
-        fence.raw.push(line);
-      }
-      continue;
-    }
-    if (f) {
-      fence = { lang: f[1] ?? "", body: [], raw: [line] };
-      continue;
-    }
-    if (!line.trim()) {
-      out.push({ block: { kind: "blank", text: "" }, raw: line });
-      continue;
-    }
-    const h = HEADING.exec(line);
-    if (h) {
-      out.push({ block: { kind: "h", level: h[1].length, text: stripInline(h[2]) }, raw: line });
-      continue;
-    }
-    const li = BULLET.exec(line) ?? NUMBERED.exec(line);
-    if (li) {
-      out.push({ block: { kind: "li", text: stripInline(li[1]) }, raw: line });
-      continue;
-    }
-    out.push({ block: { kind: "p", text: stripInline(line) }, raw: line });
-  }
-  if (fence) out.push({ block: { kind: "code", lang: fence.lang, text: fence.body.join("\n") }, raw: fence.raw.join("\n") });
-  return out;
-}
-function stripInline(s) {
-  return s.replace(/\[([^\]]+)\]\(([^)]+)\)/g, "$1 ($2)").replace(/\*\*(\S(?:[^*]*\S)?)\*\*/g, "$1").replace(/(?<!\*)\*(\S(?:[^*]*\S)?)\*(?!\*)/g, "$1").replace(/`([^`]+)`/g, "$1");
-}
-
-// src/session.ts
-var HELP_TEXT = [
-  "Type a request and press enter.",
-  "",
-  "  /tools          what the agent can do, and what it can change",
-  "  /expand #3      re-print a tool result in full",
-  "  /resume [id]    reopen an earlier conversation",
-  "  /clear          forget the conversation",
-  "  /exit           leave",
-  "",
-  /* Deliberately not 'esc stops a turn': this text is shared, and Escape is
-   * an Ink-only key -- the readline fallback has no key handler at all, so
-   * there Ctrl-C is the only way to stop a turn. Name the one that is true
-   * on both faces, and mark the other as what it is. */
-  "Ctrl-C stops a turn; twice leaves. Ctrl-D leaves. In the full terminal face, esc also stops a turn."
-].join("\n");
-var DELTA_FLUSH_MS = 50;
-var TermSession = class {
-  constructor(deps) {
-    this.deps = deps;
-  }
-  state = emptyState();
-  listeners = /* @__PURE__ */ new Set();
-  nextOrd = 1;
-  idSeq = 0;
-  pendingDelta = "";
-  flushTimer = null;
-  /* The full text streamed so far THIS ROUND (reset at beginTurn and again at
-   * every 'assistant' event, since a round of tool calls can be followed by
-   * another round of assistant text). Re-parsed into markdown blocks on every
-   * flush so all-but-the-last block can be committed as soon as it can no
-   * longer change -- see the module comment and flushDeltas(). */
-  streamFull = "";
-  /** How many leading blocks of `streamFull` have already been committed.
-   * Only the block at this index (the last one seen so far) is still live. */
-  streamCommittedBlocks = 0;
-  /* An offload is emitted just BEFORE the tool-result it belongs to (see
-   * @corenel/harness core/loop.ts: recall.record() then emit('offload'), then
-   * emit('tool-result')), and it carries the BLOB id, not the call id. So it is
-   * held here and claimed by the next result rather than looked up by id. */
-  pendingOffload = null;
-  /** The model's truth, as opposed to `committed`, which is display. */
-  history = [];
-  turnAc = null;
-  /** Monotonic turn id. Events stamped with an older one are dropped: a late
-   * delta from an aborted turn must never paint into the next one. */
-  turnId = 0;
-  activeTurn = 0;
-  pending = null;
-  draining = false;
-  /* Bumped whenever the conversation is REPLACED out from under a turn --
-   * `/clear` and `resume()`. A turn captures it when it starts and only adopts
-   * the messages it accumulated if the stamp still matches, because runAgent
-   * copies `messages` at turn start: without this, a `/clear` typed mid-turn
-   * was undone the moment the turn landed (and then written to disk), so the
-   * screen said forgotten while the next request still carried everything. */
-  historyGen = 0;
-  /* True from the moment a turn starts until the queue behind it has been
-   * drained. `status` flips to 'idle' inside runAgent's 'done' event, but
-   * runTurn then awaits persist() -- a DISK WRITE -- before it reaches drain().
-   * A line submitted in that window used to find an idle controller with a
-   * non-empty queue and start a turn immediately: the queue lost its order,
-   * and two turns could overlap, leaving a user message with no reply. */
-  settling = false;
-  /** The approval gate. Supplied by whichever face can show a prompt (readline's
-   * `ask`, the Ink modal, ...) — the controller has no rendering of its own, so
-   * it cannot build one itself. Unattached, `runTurn` simply omits `permission`
-   * from the runner args, and the loop runs every tool ungated. */
-  permission;
-  wantsExit = false;
-  attachPermission(p) {
-    this.permission = p;
-  }
-  historyForTest() {
-    return this.history;
-  }
-  getSnapshot() {
-    return this.state;
-  }
-  subscribe(fn) {
-    this.listeners.add(fn);
-    return () => {
-      this.listeners.delete(fn);
-    };
-  }
-  /** Replace state and notify. Every mutation goes through here so `seq` and the
-   * snapshot identity can never drift from the data. */
-  set(patch) {
-    this.state = { ...this.state, ...patch, seq: this.state.seq + 1 };
-    for (const fn of this.listeners) fn();
-  }
-  id(prefix) {
-    return `${prefix}${++this.idSeq}`;
-  }
-  commit(item) {
-    this.set({ committed: [...this.state.committed, item] });
-  }
-  note(level, text, detail) {
-    this.commit({ kind: "note", id: this.id("n"), level, text, ...detail ? { detail } : {} });
-  }
-  /** Open a live turn. Public-for-test until Task 4 gives it a real caller. */
-  beginTurnForTest() {
-    this.beginTurn();
-  }
-  flushDeltasForTest() {
-    this.flushDeltas();
-  }
-  beginTurn() {
-    this.streamFull = "";
-    this.streamCommittedBlocks = 0;
-    this.set({
-      live: { streaming: "", tools: [], turn: (this.state.live?.turn ?? 0) + 1 },
-      status: "running",
-      error: null,
-      turnUsage: { promptTokens: 0, completionTokens: 0 }
-    });
-  }
-  /** Commit every markdown block in `streamFull` that can no longer change --
-   * i.e. every block except the last, which more text can still extend --
-   * and return the still-live trailing block's raw text. This is what keeps
-   * the live region Ink redraws every frame bounded by one block instead of
-   * the whole reply: see the module comment for why an unbounded live region
-   * corrupts the frame once it scrolls out of the viewport.
-   *
-   * KNOWN LIMIT: any single block taller than the terminal -- not just a
-   * fenced code block, but equally one long unbroken paragraph, or any other
-   * span with no internal blank-line break -- stays "the trailing block", and
-   * so stays live and unbounded, until it closes (or the blank line that ends
-   * it arrives). That bounds the live region by one block rather than by the
-   * viewport, which the headless controller has no way to know. It is still
-   * a large improvement over the whole reply staying live, and a single block
-   * taller than the terminal is rare. */
-  commitCompletedBlocks() {
-    const spans = parseMarkdownSpans(this.streamFull);
-    if (spans.length === 0) return "";
-    while (this.streamCommittedBlocks < spans.length - 1) {
-      const span = spans[this.streamCommittedBlocks];
-      this.commit({ kind: "assistant", id: this.id("a"), text: span.raw });
-      this.streamCommittedBlocks++;
-    }
-    return spans[spans.length - 1].raw;
-  }
-  flushDeltas() {
-    if (this.flushTimer) {
-      clearTimeout(this.flushTimer);
-      this.flushTimer = null;
-    }
-    if (!this.pendingDelta) return;
-    const chunk = this.pendingDelta;
-    this.pendingDelta = "";
-    const live = this.state.live;
-    if (!live) return;
-    this.streamFull += chunk;
-    const trailing = this.commitCompletedBlocks();
-    this.set({ live: { ...this.state.live, streaming: trailing } });
-  }
-  scheduleFlush() {
-    if (this.flushTimer) return;
-    this.flushTimer = setTimeout(() => {
-      this.flushTimer = null;
-      this.flushDeltas();
-    }, DELTA_FLUSH_MS);
-    this.flushTimer.unref?.();
-  }
-  /** Commit whatever the live region still holds -- the trailing block that
-   * flushDeltas kept live, since every block before it is already committed
-   * -- and close the turn. */
-  endTurn() {
-    this.flushDeltas();
-    const live = this.state.live;
-    if (live?.streaming.trim()) {
-      this.commit({ kind: "assistant", id: this.id("a"), text: live.streaming });
-    }
-    const stopped = this.state.status === "aborting";
-    this.set({ live: null, status: "idle" });
-    this.streamFull = "";
-    this.streamCommittedBlocks = 0;
-    if (stopped) this.note("info", "(stopped)");
-  }
-  handleEvent(e) {
-    this.deps.onEvent?.(e);
-    switch (e.type) {
-      case "turn": {
-        const live = this.state.live;
-        if (live) this.set({ live: { ...live, turn: e.turn } });
-        break;
-      }
-      case "assistant-delta":
-        this.pendingDelta += e.delta;
-        this.scheduleFlush();
-        break;
-      case "assistant": {
-        this.flushDeltas();
-        const live = this.state.live;
-        const trailing = live?.streaming ?? "";
-        if (trailing.trim()) {
-          this.commit({ kind: "assistant", id: this.id("a"), text: trailing });
-        } else if (this.streamCommittedBlocks === 0 && e.content.trim()) {
-          this.commit({ kind: "assistant", id: this.id("a"), text: e.content });
-        }
-        if (live) this.set({ live: { ...this.state.live, streaming: "" } });
-        this.streamFull = "";
-        this.streamCommittedBlocks = 0;
-        break;
-      }
-      case "tool-call": {
-        this.flushDeltas();
-        const live = this.state.live;
-        if (!live) break;
-        const tool = {
-          callId: e.id,
-          ord: this.nextOrd++,
-          name: e.name,
-          subject: describeToolCall(e.name, e.args)
-        };
-        this.set({ live: { ...live, tools: [...live.tools, tool] } });
-        break;
-      }
-      case "tool-result": {
-        this.flushDeltas();
-        const live = this.state.live;
-        const pending = live?.tools.find((t) => t.callId === e.id);
-        const isError = e.isError === true;
-        const offload = this.pendingOffload;
-        this.pendingOffload = null;
-        const item = {
-          kind: "tool",
-          id: this.id("t"),
-          callId: e.id,
-          ord: pending?.ord ?? this.nextOrd++,
-          name: e.name,
-          subject: pending?.subject ?? "",
-          preview: capPreview(e.result, isError),
-          isError,
-          ...e.durationMs !== void 0 ? { durationMs: e.durationMs } : {},
-          ...offload ? { offloadedBytes: offload.bytes, offloadRefId: offload.refId } : {}
-        };
-        if (live) {
-          this.state = {
-            ...this.state,
-            live: { ...live, tools: live.tools.filter((t) => t.callId !== e.id) }
-          };
-        }
-        this.commit(item);
-        break;
-      }
-      case "offload":
-        this.pendingOffload = { refId: e.id, bytes: e.bytes };
-        break;
-      case "permission":
-      case "permission-audit":
-        break;
-      case "policy-violation":
-        this.note(
-          e.action === "stop" ? "error" : "warn",
-          e.action === "stop" ? `blocked  ${e.message}` : `warning  ${e.message}`,
-          e.tool
-        );
-        break;
-      case "heal":
-        if (e.record.outcome === "abandoned" || e.record.outcome === "exhausted") {
-          this.note("warn", `recovery gave up  ${e.record.error ?? e.record.strategy}`);
-        }
-        break;
-      case "usage":
-        this.set({
-          usage: {
-            promptTokens: this.state.usage.promptTokens + e.usage.promptTokens,
-            completionTokens: this.state.usage.completionTokens + e.usage.completionTokens
-          },
-          turnUsage: {
-            promptTokens: this.state.turnUsage.promptTokens + e.usage.promptTokens,
-            completionTokens: this.state.turnUsage.completionTokens + e.usage.completionTokens
-          }
-        });
-        break;
-      case "artifact":
-        this.note("info", `artifact  ${e.kind}${e.title ? `  ${e.title}` : ""}`);
-        break;
-      case "budget-stop":
-      case "budget-warn":
-        this.note("warn", `budget  ${e.type === "budget-stop" ? "stopped" : "over"}`);
-        break;
-      case "error":
-        this.flushDeltas();
-        this.note("error", e.message);
-        this.set({ error: e.message });
-        break;
-      case "done":
-        this.endTurn();
-        break;
-      default:
-        break;
-    }
-  }
-  /** Route one line: a command runs here; anything else is a turn. */
-  async submit(text) {
-    const line = text.trim();
-    if (!line) return;
-    const cmd = parseCommand(line);
-    if (cmd) {
-      await this.runCommand(cmd);
-      return;
-    }
-    if (this.state.status !== "idle" || this.settling) {
-      this.set({ queued: [...this.state.queued, line] });
-      return;
-    }
-    await this.runTurn(line);
-  }
-  async runCommand(cmd) {
-    switch (cmd.cmd) {
-      case "exit":
-        this.wantsExit = true;
-        return;
-      case "clear":
-        this.history = [];
-        this.historyGen++;
-        this.set({
-          committed: [],
-          usage: { promptTokens: 0, completionTokens: 0 },
-          turnUsage: { promptTokens: 0, completionTokens: 0 }
-        });
-        return;
-      case "tools":
-        this.note("info", formatTools(this.deps.tools));
-        return;
-      case "help":
-        this.note("info", HELP_TEXT);
-        return;
-      case "expand": {
-        if (cmd.ord === void 0) {
-          this.note("warn", "usage: /expand #3");
-          return;
-        }
-        await this.expand(cmd.ord);
-        return;
-      }
-      case "resume":
-        await this.resume(cmd.id);
-        return;
-    }
-  }
-  /** Save after the turn, never during: a half-written turn is a lie on disk. */
-  async persist() {
-    const p = this.deps.persistence;
-    if (!p) return;
-    try {
-      const title = this.state.session?.title ?? titleFrom(this.history);
-      const { id } = await p.save({ id: this.state.session?.id ?? null, title, messages: this.history });
-      this.set({ session: { id, title } });
-    } catch (e) {
-      this.note("warn", `could not save this conversation: ${e instanceof Error ? e.message : String(e)}`);
-    }
-  }
-  /** Reopen a conversation: `id` if given, otherwise the most recent. */
-  async resume(id) {
-    const p = this.deps.persistence;
-    if (!p) {
-      this.note("warn", "this session is not being saved, so there is nothing to resume");
-      return;
-    }
-    const loaded = await p.load(id);
-    if (!loaded) {
-      this.note("warn", id ? `no conversation ${id}` : "no earlier conversation to resume");
-      return;
-    }
-    this.history = loaded.messages;
-    this.historyGen++;
-    this.set({
-      committed: committedFromMessages(loaded.messages),
-      transcriptGen: this.state.transcriptGen + 1,
-      session: { id: loaded.id, title: loaded.title }
-    });
-  }
-  /** Re-print a committed tool row in full, as a NEW block at the bottom.
-   * Inline rendering owns this trade: the original row's bytes belong to the
-   * terminal's scrollback and cannot be rewritten in place. */
-  async expand(ord) {
-    const row = this.state.committed.find((i) => i.kind === "tool" && i.ord === ord);
-    if (!row || row.kind !== "tool") {
-      this.note("warn", `no tool result #${ord} in this conversation`);
-      return;
-    }
-    const full = await this.fullResult(row.id, row);
-    this.note("info", `#${row.ord}  ${row.name}  ${row.subject}`, full);
-  }
-  /** The full body of a committed row. `committed` only ever keeps the capped
-   * `preview`, and a second copy would be redundant AND wrong: `history`
-   * already carries the exact string the model saw for this call (the full
-   * body when it wasn't offloaded, the short offload ref when it was — see
-   * @corenel/harness core/loop.ts's `messages.push({ role: 'tool', ... })`),
-   * and `history` is cleared by `/clear`, so a stale row can't outlive the
-   * conversation it belongs to the way a side map would. Task 8 adds the (a)
-   * branch below: reading an offloaded body back out of the blob store by
-   * `row.offloadRefId` — the seam, not the wiring: the CLI does not pass
-   * `deps.recall` (context compression in node is a separate feature), so
-   * this branch is currently always skipped in practice. */
-  async fullResult(_id, row) {
-    if (row.offloadedBytes !== void 0 && this.deps.recall) {
-      const full = await this.deps.recall(row.offloadRefId ?? row.id);
-      if (full) return full;
-    }
-    const msg = this.history.find(
-      (m) => m.role === "tool" && m.tool_call_id === row.callId
-    );
-    if (msg && typeof msg.content === "string") return msg.content;
-    return row.preview.join("\n");
-  }
-  async runTurn(line) {
-    this.settling = true;
-    this.commit({ kind: "user", id: this.id("u"), text: line });
-    this.history.push({ role: "user", content: line });
-    const gen = this.historyGen;
-    const ac = new AbortController();
-    this.turnAc = ac;
-    const mine = ++this.turnId;
-    this.activeTurn = mine;
-    this.beginTurn();
-    const run = this.deps.runner ?? runAgent;
-    try {
-      const result = await run({
-        client: this.deps.client,
-        model: this.deps.model,
-        ...this.deps.system ? { system: this.deps.system } : {},
-        messages: this.history,
-        tools: this.deps.tools,
-        toolCtx: this.deps.toolCtx(ac.signal, (q) => this.askUser(q)),
-        signal: ac.signal,
-        ...this.permission ? { permission: this.permission } : {},
-        onEvent: (e) => {
-          if (this.activeTurn === mine) this.handleEvent(e);
-        }
-      });
-      if (this.activeTurn !== mine) return;
-      if (ac.signal.aborted || result.stopReason === "aborted") {
-        await this.finishAbandoned(gen);
-        return;
-      }
-      if (this.historyGen === gen) this.history = result.messages;
-      this.endTurn();
-      await this.persist();
-      if (this.activeTurn === mine) this.activeTurn = 0;
-    } catch (e) {
-      if (this.activeTurn === mine) {
-        if (!ac.signal.aborted) this.note("error", e instanceof Error ? e.message : String(e));
-        await this.finishAbandoned(gen);
-      }
-    } finally {
-      if (this.turnAc === ac) this.turnAc = null;
-      this.forceClosePending();
-      await this.drain();
-      if (!this.draining) this.settling = false;
-    }
-  }
-  /** Close out a turn that produced nothing usable -- aborted, or failed.
-   * Drops the abandoned user message: a user message with no reply, or a tool
-   * call with no result, poisons the next request. Exactly once, and never when
-   * the conversation was replaced under it (`/clear`, `/resume`), where the
-   * message it would drop belongs to someone else's history. */
-  async finishAbandoned(gen) {
-    if (this.historyGen === gen) this.history = this.history.slice(0, -1);
-    this.endTurn();
-    await this.persist();
-    this.activeTurn = 0;
-  }
-  async drain() {
-    if (this.draining) return;
-    this.draining = true;
-    try {
-      for (; ; ) {
-        const [next, ...rest] = this.state.queued;
-        if (next === void 0) break;
-        this.set({ queued: rest });
-        await this.runTurn(next);
-      }
-    } finally {
-      this.draining = false;
-    }
-  }
-  /** Stop the TURN, never the process. A long tool call you regret is the common
-   * case, and killing the shell to escape it loses the conversation. */
-  abort() {
-    if (this.state.status === "idle" && !this.pending) return;
-    this.set({ status: "aborting" });
-    this.forceClosePending();
-    this.turnAc?.abort();
-  }
-  askPermission(req) {
-    if (this.deps.approveAll) return Promise.resolve("allow");
-    if (this.pending) throw new Error("a question is already open");
-    const detail = req.input;
-    const shown = typeof detail?.command === "string" ? detail.command : typeof detail?.path === "string" ? detail.path : "";
-    this.set({ modal: { kind: "permission", tool: req.tool, detail: shown } });
-    return new Promise((resolve) => {
-      this.pending = { resolve: (v) => resolve(v ?? "deny") };
-    });
-  }
-  askUser(questions) {
-    if (this.pending) throw new Error("a question is already open");
-    this.set({ modal: { kind: "user", questions } });
-    return new Promise((resolve) => {
-      this.pending = { resolve: (v) => resolve(v ?? null) };
-    });
-  }
-  /** The view's answer to whichever modal is open. */
-  answer(value) {
-    this.resolvePending(value);
-  }
-  /** Force-close whatever modal is open, on turn teardown or `abort()`. The
-   * sentinel must match the modal's OWN contract, not a shared default:
-   * `askPermission` promises `PermissionDecision`, where `'deny'` is a real
-   * value; `askUser` promises `AskAnswers | null`, and `'deny'` there would be
-   * a bogus truthy string standing in for the documented "dismissed" (`null`)
-   * outcome that `askUserTool` (packages/harness/tools/builtins.ts) checks for. */
-  forceClosePending() {
-    if (!this.pending) return;
-    this.resolvePending(this.state.modal?.kind === "user" ? null : "deny");
-  }
-  resolvePending(value) {
-    const p = this.pending;
-    if (!p) return;
-    this.pending = null;
-    this.set({ modal: null });
-    p.resolve(value);
-  }
-};
-
-export {
-  matchesAnyGlob,
-  STANDARD_POLICY,
-  parseMarkdown,
-  DELTA_FLUSH_MS,
-  TermSession
-};