@qloo/qloo-harness 0.1.18

package/dist/runtime/explore-policy.js

@@ -0,0 +1,666 @@
+import { createRequire as __qlooCreateRequire } from "node:module";
+const require = __qlooCreateRequire(import.meta.url);
+
+// apps/qloo-harness/dist/runtime/explore-policy.js
+import { findGuidedGoal, guidedGoalLabel, QLOO_GUIDED_GOALS, qlooNextActions, qlooStarterIdeaLines } from "../guided-journey.js";
+import { getQlooProfileDefinition } from "../profiles.js";
+import { applyResolutionChoices, formatQlooResolutionCandidateLabels, paginateQlooResult, parseQlooRawPage, resolutionCandidates } from "../qloo-presentation.js";
+import { QLOO_NO_GUIDED_START_ENVIRONMENT_VARIABLE } from "../setup.js";
+import { isBlockedPiInteractiveCommand } from "./pi-command-policy.js";
+import { renderQlooHeader } from "./qloo-header.js";
+var QLOO_WORKSPACE_TOOL_NAMES = [
+  ...getQlooProfileDefinition("build").workspaceTools
+];
+var QLOO_SESSION_STATE_ENTRY_TYPE = "qloo.workflow-state";
+var QLOO_SESSION_STATE_SCHEMA_VERSION = "1.4";
+var QLOO_NEXT_WIDGET_KEY = "qloo-next-actions";
+var QLOO_START_WIDGET_KEY = "qloo-start-ideas";
+var AUTOMATIC_DIAGNOSTIC_CODES = /* @__PURE__ */ new Set([
+  "QLOO_AUTH",
+  "QLOO_CONNECT",
+  "QLOO_DNS",
+  "QLOO_TIMEOUT",
+  "QLOO_TLS",
+  "RESOLVER_CONNECT",
+  "RESOLVER_TIMEOUT"
+]);
+var reservedBuiltInTools = /* @__PURE__ */ new Set([
+  ...QLOO_WORKSPACE_TOOL_NAMES,
+  "grep",
+  "find",
+  "ls"
+]);
+function buildExploreToolNames(tools) {
+  return buildProfileToolNames("explore", tools);
+}
+function buildProfileToolNames(profile, tools) {
+  validateExploreTools(tools);
+  return [
+    ...getQlooProfileDefinition(profile).workspaceTools,
+    ...tools.map(({ name }) => name)
+  ];
+}
+function validateExploreTools(tools) {
+  const names = /* @__PURE__ */ new Set();
+  for (const tool of tools) {
+    const name = tool.name.trim();
+    if (name.length === 0) {
+      throw new Error("Qloo tool names must not be empty");
+    }
+    if (reservedBuiltInTools.has(name)) {
+      throw new Error(`Qloo tool name conflicts with a reserved Pi built-in: ${name}`);
+    }
+    if (names.has(name)) {
+      throw new Error(`Duplicate Qloo tool name: ${name}`);
+    }
+    names.add(name);
+  }
+}
+function safeApprovalDetail(toolName, input) {
+  const candidate = toolName === "bash" ? input.command : input.path ?? input.file_path;
+  if (typeof candidate !== "string" || candidate.trim().length === 0)
+    return toolName;
+  const sanitized = candidate.replace(/[\u0000-\u001f\u007f]/gu, " ").trim();
+  return sanitized.length > 240 ? `${sanitized.slice(0, 240)}\u2026` : sanitized;
+}
+function stableToolSignature(toolName, input) {
+  const normalize = (value) => {
+    if (Array.isArray(value))
+      return value.map(normalize);
+    if (value === null || typeof value !== "object")
+      return value;
+    return Object.fromEntries(Object.entries(value).sort(([left], [right]) => left.localeCompare(right)).map(([key, item]) => [key, normalize(item)]));
+  };
+  return `${toolName}:${JSON.stringify(normalize(input))}`;
+}
+var sensitiveResultKey = /(?:api[_-]?key|authorization|credential|password|secret|token)/iu;
+function redactSensitiveResult(value, depth = 0) {
+  if (depth >= 8)
+    return "[detail omitted]";
+  if (Array.isArray(value))
+    return value.map((item) => redactSensitiveResult(item, depth + 1));
+  if (value === null || typeof value !== "object")
+    return value;
+  return Object.fromEntries(Object.entries(value).map(([key, item]) => [
+    key,
+    sensitiveResultKey.test(key) ? "[redacted]" : redactSensitiveResult(item, depth + 1)
+  ]));
+}
+function boundedJsonValue(value, maximumBytes) {
+  try {
+    const serialized = JSON.stringify(redactSensitiveResult(value));
+    if (Buffer.byteLength(serialized) > maximumBytes)
+      return void 0;
+    return JSON.parse(serialized);
+  } catch {
+    return void 0;
+  }
+}
+function boundedWorkflowInput(input) {
+  return boundedJsonValue(input, 16384);
+}
+function branchHasConversation(entries) {
+  return entries.some((entry) => {
+    if (entry === null || typeof entry !== "object" || Array.isArray(entry))
+      return false;
+    const record = entry;
+    return record.type === "message" || record.type === "custom_message" || record.type === "compaction";
+  });
+}
+function compactDoctorRecovery(report, recovery) {
+  const record = report !== null && typeof report === "object" && !Array.isArray(report) ? report : void 0;
+  const checks = Array.isArray(record?.checks) ? record.checks.filter((check) => check !== null && typeof check === "object" && !Array.isArray(check)).filter((check) => check.status !== "ok").slice(0, 3).map((check) => typeof check.message === "string" ? check.message : void 0).filter((message) => Boolean(message)) : [];
+  const next = checks[0] ?? (typeof recovery === "string" && recovery.trim() ? recovery : "Run /doctor network before retrying.");
+  return [
+    "Qloo automatically checked the failing connection.",
+    `Diagnosis: ${String(record?.status ?? "unavailable")}`,
+    `Next step: ${next}`,
+    "Use /doctor network for the full report or /trace for the recorded failure."
+  ].join("\n");
+}
+function requestPreviews(workflow) {
+  const provenance = workflow.provenance;
+  if (provenance === null || typeof provenance !== "object" || Array.isArray(provenance)) {
+    return void 0;
+  }
+  return provenance.requests;
+}
+function createHarnessPolicyExtension(profile, allowedToolNames, runtimeInfo, commandActions = {}) {
+  return {
+    name: `qloo-${profile}-policy`,
+    hidden: true,
+    factory(pi) {
+      let autocompletePolicyInstalled = false;
+      let starterIdeasShown = false;
+      let diagnosedThisTurn = false;
+      let toolCallsThisTurn = 0;
+      const identicalCallsThisTurn = /* @__PURE__ */ new Map();
+      let lastQlooResult;
+      let lastQlooRawResult;
+      let lastQlooInput;
+      let lastQlooToolName;
+      let rawPage = 1;
+      let activeProfile = profile;
+      const customToolNames = [...allowedToolNames].filter((name) => !reservedBuiltInTools.has(name));
+      const activeDefinition = () => getQlooProfileDefinition(activeProfile);
+      const activeAllowedToolNames = () => /* @__PURE__ */ new Set([
+        ...activeDefinition().workspaceTools,
+        ...customToolNames
+      ]);
+      const activateProfile = (nextProfile, context, reason = "resume") => {
+        activeProfile = nextProfile;
+        pi.setActiveTools([...activeAllowedToolNames()]);
+        const status = `Qloo \xB7 ${nextProfile}`;
+        context?.ui?.setStatus?.("qloo-profile", context.ui.theme?.fg("accent", status) ?? status);
+        context?.ui?.notify(reason === "resume" ? `Qloo resumed in the read-only ${nextProfile} profile; prior build authority was not restored.` : `Qloo switched to the ${nextProfile} profile for this guided path.`, reason === "resume" ? "warning" : "info");
+      };
+      const restoreLastQlooResult = (context) => {
+        const entries = context.sessionManager?.getBranch() ?? [];
+        for (let index = entries.length - 1; index >= 0; index -= 1) {
+          const entry = entries[index];
+          if (entry === null || typeof entry !== "object")
+            continue;
+          const record = entry;
+          if (record.type !== "custom" || record.customType !== QLOO_SESSION_STATE_ENTRY_TYPE)
+            continue;
+          const data = record.data;
+          if (data === null || typeof data !== "object" || Array.isArray(data))
+            continue;
+          const workflow = data.workflow;
+          if (workflow !== null && typeof workflow === "object" && !Array.isArray(workflow)) {
+            lastQlooResult = workflow;
+            const restoredInput = lastQlooResult.input;
+            if (restoredInput !== null && typeof restoredInput === "object" && !Array.isArray(restoredInput)) {
+              lastQlooInput = restoredInput;
+            }
+            if (typeof lastQlooResult.tool_name === "string") {
+              lastQlooToolName = lastQlooResult.tool_name;
+            }
+          }
+          return;
+        }
+      };
+      const notifyJson = (context, label, value, maximumCharacters = 4e3) => {
+        const serialized = JSON.stringify(redactSensitiveResult(value), null, 2);
+        const bounded = serialized.length > maximumCharacters ? `${serialized.slice(0, maximumCharacters)}
+\u2026` : serialized;
+        context.ui.notify(`${label}
+${bounded}`);
+      };
+      const setNextWidget = (context) => {
+        if (context?.mode !== "tui" || !context.ui?.setWidget)
+          return;
+        context.ui.setWidget(QLOO_NEXT_WIDGET_KEY, ["Next: /next choose a follow-up \xB7 /why interpretation \xB7 /request API request"], { placement: "belowEditor" });
+      };
+      const recordQlooResult = (toolName, input, details, context) => {
+        const boundedInput = boundedWorkflowInput(input);
+        const boundedResolution = boundedJsonValue(details.resolution, 24576);
+        const boundedWarnings = boundedJsonValue(details.warnings, 4096);
+        const boundedProvenance = boundedJsonValue(details.provenance, 24576);
+        const boundedExecution = boundedJsonValue(details.execution, 4096);
+        lastQlooRawResult = details;
+        rawPage = 1;
+        lastQlooInput = boundedInput;
+        lastQlooToolName = toolName;
+        lastQlooResult = {
+          schema_version: details.schema_version,
+          operation: details.operation,
+          tool_name: toolName,
+          ...boundedInput ? { input: boundedInput } : {},
+          status: details.status,
+          result_count: details.result_count,
+          query_intent: details.query_intent,
+          error: details.error,
+          ...boundedResolution !== void 0 ? { resolution: boundedResolution } : {},
+          ...boundedWarnings !== void 0 ? { warnings: boundedWarnings } : {},
+          ...boundedProvenance !== void 0 ? { provenance: boundedProvenance } : {},
+          ...boundedExecution !== void 0 ? { execution: boundedExecution } : {}
+        };
+        pi.appendEntry(QLOO_SESSION_STATE_ENTRY_TYPE, {
+          schema_version: QLOO_SESSION_STATE_SCHEMA_VERSION,
+          profile: activeProfile,
+          workflow: lastQlooResult
+        });
+        setNextWidget(context);
+      };
+      const runDoctorAction = async (context, network, compact = false, recovery) => {
+        if (!commandActions.doctor) {
+          context.ui.notify("In-chat diagnostics are unavailable in this embedded runtime. Run qloo doctor --network.", "warning");
+          return;
+        }
+        context.ui.notify(network ? "Running bounded Qloo network diagnostics\u2026" : "Running Qloo diagnostics\u2026");
+        try {
+          const report = await commandActions.doctor(network);
+          if (compact) {
+            context.ui.notify(compactDoctorRecovery(report, recovery));
+          } else {
+            notifyJson(context, "Qloo doctor", report, 8e3);
+          }
+        } catch {
+          context.ui.notify("Qloo diagnostics could not complete. Run qloo doctor --network from the terminal.", "error");
+        }
+      };
+      const showRequestAction = (context) => {
+        if (!lastQlooResult) {
+          context.ui.notify("No Qloo workflow request has been recorded in this session yet.", "warning");
+          return;
+        }
+        const requests = requestPreviews(lastQlooResult);
+        if (!Array.isArray(requests) || requests.length === 0) {
+          context.ui.notify("This transport did not expose a safe request preview. Use /why and /sources to inspect the normalized workflow.", "warning");
+          return;
+        }
+        notifyJson(context, "Latest Qloo API request", requests, 12e3);
+      };
+      const retryLastWorkflow = async (context) => {
+        if (!lastQlooToolName || !lastQlooInput) {
+          context.ui.notify("No replayable Qloo workflow input has been recorded in this session yet.", "warning");
+          return;
+        }
+        if (!commandActions.retry) {
+          context.ui.notify("Retry is unavailable in this embedded runtime.", "warning");
+          return;
+        }
+        context.ui.notify(`Retrying ${lastQlooToolName} once on ${runtimeInfo?.transport ?? "the selected transport"}\u2026`);
+        try {
+          const details = await commandActions.retry(lastQlooToolName, lastQlooInput);
+          recordQlooResult(lastQlooToolName, lastQlooInput, details, context);
+          context.ui.notify([
+            `${lastQlooToolName} retry completed.`,
+            `Status: ${String(details.status ?? "unknown")}`,
+            `Results: ${String(details.result_count ?? "unknown")}`,
+            "Use /next, /raw, /why, /request, /sources, or /trace to inspect it."
+          ].join("\n"));
+        } catch {
+          context.ui.notify("The Qloo retry failed inside the harness. Use /trace or qloo doctor --network.", "error");
+        }
+      };
+      const activateGuidedGoal = (goal, context) => {
+        if (goal.profile && goal.profile !== activeProfile) {
+          activateProfile(goal.profile, context, "journey");
+        }
+      };
+      const showGuidedStart = async (context) => {
+        if (context.mode !== "tui" || !context.hasUI) {
+          context.ui.notify("Guided start is available in the interactive terminal.", "warning");
+          return;
+        }
+        context.ui.setWidget(QLOO_START_WIDGET_KEY, void 0);
+        const selected = await context.ui.select("What would you like to do with Qloo?", QLOO_GUIDED_GOALS.map(guidedGoalLabel));
+        if (!selected)
+          return;
+        const goal = findGuidedGoal(selected);
+        if (!goal)
+          return;
+        activateGuidedGoal(goal, context);
+        if (goal.id === "diagnose") {
+          await runDoctorAction(context, true);
+          return;
+        }
+        if (goal.id === "blank" || goal.starters.length === 0)
+          return;
+        const ownPrompt = "Write my own prompt";
+        const starterLabel = await context.ui.select(goal.label, [...goal.starters.map(({ label }) => label), ownPrompt]);
+        if (!starterLabel || starterLabel === ownPrompt)
+          return;
+        const starter = goal.starters.find(({ label }) => label === starterLabel);
+        if (!starter)
+          return;
+        context.ui.setEditorText(starter.prompt);
+        context.ui.notify("Starter added to the editor. Replace the bracketed details, then press Enter.");
+      };
+      const showStarterIdeas = (context) => {
+        if (context.mode !== "tui" || !context.hasUI)
+          return;
+        context.ui.setWidget(QLOO_START_WIDGET_KEY, (_tui, theme) => ({
+          render(width) {
+            const lines = qlooStarterIdeaLines(width);
+            return lines.map((line, index) => {
+              if (index === 0)
+                return theme.bold(theme.fg("accent", line));
+              if (index === lines.length - 1)
+                return theme.fg("dim", line);
+              return theme.fg("muted", line);
+            });
+          },
+          invalidate() {
+          }
+        }));
+      };
+      const showNextActions = async (context) => {
+        if (!lastQlooResult) {
+          context.ui.notify("No Qloo result is available yet. Use /start for guided examples.", "warning");
+          return;
+        }
+        const actions = qlooNextActions(lastQlooResult);
+        const selected = await context.ui.select("What would you like to do next?", actions.map(({ label }) => label));
+        const action = actions.find(({ label }) => label === selected);
+        if (!action)
+          return;
+        if (action.kind === "prompt") {
+          if (action.profile && action.profile !== activeProfile) {
+            activateProfile(action.profile, context, "journey");
+          }
+          context.ui.setEditorText(action.value);
+          return;
+        }
+        if (action.value === "request")
+          showRequestAction(context);
+        else if (action.value === "why") {
+          notifyJson(context, "Latest Qloo query intent", lastQlooResult.query_intent);
+        } else if (action.value === "doctor network") {
+          await runDoctorAction(context, true);
+        } else if (action.value === "retry") {
+          await retryLastWorkflow(context);
+        }
+      };
+      const maybeRunAutomaticDiagnosis = async (details, context) => {
+        if (diagnosedThisTurn || !commandActions.doctor || details.status !== "error")
+          return;
+        const error = details.error;
+        if (error === null || typeof error !== "object" || Array.isArray(error))
+          return;
+        const errorRecord = error;
+        if (typeof errorRecord.code !== "string" || !AUTOMATIC_DIAGNOSTIC_CODES.has(errorRecord.code)) {
+          return;
+        }
+        diagnosedThisTurn = true;
+        await runDoctorAction(context, true, true, errorRecord.recovery);
+      };
+      pi.registerCommand("start", {
+        description: "Choose a guided Qloo goal and editable starter prompt",
+        handler: async (_args, context) => showGuidedStart(context)
+      });
+      pi.registerCommand("status", {
+        description: "Show Qloo profile, transport, model, workspace, and context usage",
+        handler: async (_args, context) => {
+          const usage = context.getContextUsage();
+          const model = context.model ? `${context.model.provider}/${context.model.id}` : "unavailable";
+          context.ui.notify([
+            "Qloo status",
+            `Profile: ${activeProfile}`,
+            `Transport: ${runtimeInfo ? `${runtimeInfo.transport} (${runtimeInfo.transportName})` : "not declared"}`,
+            `Resolution: ${runtimeInfo?.resolution ? `${runtimeInfo.resolution.name} (${runtimeInfo.resolution.tag_strategy}${runtimeInfo.resolution.uses_model ? ", model-assisted" : ""})` : "not declared"}`,
+            `Fallback: ${runtimeInfo?.fallback ?? "none"}`,
+            `Model: ${model}`,
+            `Workspace: ${context.cwd}`,
+            `Context: ${usage?.tokens ?? "unknown"}/${usage?.contextWindow ?? "unknown"} tokens${usage?.percent === null || usage?.percent === void 0 ? "" : ` (${usage.percent.toFixed(1)}%)`}`,
+            `Turn budget: ${activeDefinition().maxToolCallsPerTurn} calls; ${activeDefinition().maxIdenticalToolCallsPerTurn} identical calls`
+          ].join("\n"));
+        }
+      });
+      pi.registerCommand("why", {
+        description: "Show the normalized intent for the latest Qloo workflow",
+        handler: async (_args, context) => {
+          if (!lastQlooResult?.query_intent) {
+            context.ui.notify("No Qloo workflow intent has been recorded in this session yet.", "warning");
+            return;
+          }
+          notifyJson(context, "Latest Qloo query intent", lastQlooResult.query_intent);
+        }
+      });
+      pi.registerCommand("sources", {
+        description: "Show contract and API provenance for the latest Qloo workflow",
+        handler: async (_args, context) => {
+          if (!lastQlooResult) {
+            context.ui.notify("No Qloo workflow provenance has been recorded in this session yet.", "warning");
+            return;
+          }
+          notifyJson(context, "Latest Qloo provenance", {
+            schema_version: lastQlooResult.schema_version,
+            operation: lastQlooResult.operation,
+            resolution: lastQlooResult.resolution,
+            warnings: lastQlooResult.warnings,
+            provenance: lastQlooResult.provenance
+          });
+        }
+      });
+      pi.registerCommand("request", {
+        description: "Show the safe API request preview for the latest Qloo workflow",
+        handler: async (_args, context) => showRequestAction(context)
+      });
+      pi.registerCommand("trace", {
+        description: "Show safe execution metadata for the latest Qloo workflow",
+        handler: async (_args, context) => {
+          if (!lastQlooResult) {
+            context.ui.notify("No Qloo workflow execution has been recorded in this session yet.", "warning");
+            return;
+          }
+          notifyJson(context, "Latest Qloo execution", {
+            operation: lastQlooResult.operation,
+            status: lastQlooResult.status,
+            result_count: lastQlooResult.result_count,
+            error: lastQlooResult.error,
+            execution: lastQlooResult.execution
+          });
+        }
+      });
+      pi.registerCommand("raw", {
+        description: "Show a bounded result page; pass a page number, next, or prev",
+        handler: async (args, context) => {
+          if (!lastQlooRawResult) {
+            context.ui.notify(lastQlooResult ? "The latest raw result is not duplicated across resume. Use /retry to execute the recorded input again." : "No Qloo workflow result has been recorded in this session yet.", "warning");
+            return;
+          }
+          const requestedPage = parseQlooRawPage(args, rawPage);
+          if (requestedPage === void 0) {
+            context.ui.notify("Usage: /raw [page|next|prev]", "warning");
+            return;
+          }
+          const page = paginateQlooResult(lastQlooRawResult, requestedPage);
+          const pageInfo = page.page;
+          if (pageInfo !== null && typeof pageInfo === "object" && !Array.isArray(pageInfo)) {
+            const normalizedPage = pageInfo.number;
+            if (typeof normalizedPage === "number")
+              rawPage = normalizedPage;
+          }
+          notifyJson(context, `Latest normalized Qloo result \xB7 page ${rawPage}`, redactSensitiveResult(page), 12e3);
+        }
+      });
+      pi.registerCommand("next", {
+        description: "Choose a useful follow-up for the latest Qloo workflow",
+        handler: async (_args, context) => showNextActions(context)
+      });
+      pi.registerCommand("doctor", {
+        description: "Run static Qloo diagnostics; pass network for one active API probe",
+        handler: async (args, context) => {
+          const value = args.trim();
+          if (value !== "" && value !== "network" && value !== "--network") {
+            context.ui.notify("Usage: /doctor [network]", "warning");
+            return;
+          }
+          const network = value !== "";
+          await runDoctorAction(context, network);
+        }
+      });
+      pi.registerCommand("retry", {
+        description: "Replay the latest recorded Qloo workflow input once on the same transport",
+        handler: async (args, context) => {
+          if (args.trim().length > 0) {
+            context.ui.notify("Usage: /retry", "warning");
+            return;
+          }
+          await retryLastWorkflow(context);
+        }
+      });
+      pi.on("session_start", async (event, context) => {
+        if (activeProfile === "build" && event.reason !== "startup") {
+          activateProfile("plan", context);
+        }
+        restoreLastQlooResult(context);
+        if (context.mode !== "tui")
+          return;
+        context.ui.setTitle("Qloo");
+        context.ui.setHeader((_tui, theme) => ({
+          render: (width) => renderQlooHeader(theme, width, activeProfile),
+          invalidate() {
+          }
+        }));
+        context.ui.setStatus("qloo-profile", context.ui.theme.fg("accent", `Qloo \xB7 ${activeProfile}`));
+        if (!autocompletePolicyInstalled) {
+          context.ui.addAutocompleteProvider((current) => ({
+            ...current.triggerCharacters ? { triggerCharacters: [...current.triggerCharacters] } : {},
+            async getSuggestions(lines, cursorLine, cursorCol, options) {
+              const suggestions = await current.getSuggestions(lines, cursorLine, cursorCol, options);
+              if (!suggestions)
+                return null;
+              return {
+                ...suggestions,
+                items: suggestions.items.filter((item) => !isBlockedPiInteractiveCommand(item.value))
+              };
+            },
+            applyCompletion: (...args) => current.applyCompletion(...args),
+            ...current.shouldTriggerFileCompletion ? {
+              shouldTriggerFileCompletion: (...args) => current.shouldTriggerFileCompletion?.(...args) ?? false
+            } : {}
+          }));
+          autocompletePolicyInstalled = true;
+        }
+        const guidedStartEnabled = process.env[QLOO_NO_GUIDED_START_ENVIRONMENT_VARIABLE] !== "1";
+        const freshSession = (event.reason === "startup" || event.reason === "new") && !branchHasConversation(context.sessionManager.getBranch());
+        if (guidedStartEnabled && freshSession && !starterIdeasShown) {
+          starterIdeasShown = true;
+          showStarterIdeas(context);
+        }
+      });
+      pi.on("project_trust", () => ({ trusted: "no", remember: false }));
+      pi.on("turn_start", (_event, context) => {
+        diagnosedThisTurn = false;
+        toolCallsThisTurn = 0;
+        identicalCallsThisTurn.clear();
+        if (context.mode === "tui") {
+          context.ui.setWidget(QLOO_START_WIDGET_KEY, void 0);
+          context.ui.setWidget(QLOO_NEXT_WIDGET_KEY, void 0);
+        }
+      });
+      pi.on("tool_execution_start", (event, context) => {
+        if (!event.toolName.startsWith("qloo_"))
+          return;
+        context.ui.setWorkingMessage("Qloo \xB7 resolving and querying\u2026");
+      });
+      pi.on("tool_execution_end", (event, context) => {
+        if (!event.toolName.startsWith("qloo_"))
+          return;
+        context.ui.setWorkingMessage();
+      });
+      pi.on("tool_result", async (event, context) => {
+        if (!event.toolName.startsWith("qloo_") || event.toolName === "qloo_capabilities")
+          return;
+        if (event.details === null || typeof event.details !== "object" || Array.isArray(event.details))
+          return;
+        const details = event.details;
+        const issues = resolutionCandidates(details);
+        if (issues.length === 0 || !context.hasUI || !commandActions.retry) {
+          recordQlooResult(event.toolName, event.input, details, context);
+          await maybeRunAutomaticDiagnosis(details, context);
+          return;
+        }
+        const choices = [];
+        for (const issue of issues) {
+          const labels = formatQlooResolutionCandidateLabels(issue.candidates).map((label, index) => `${index + 1}. ${label}`);
+          const cancelLabel = "Cancel and ask me";
+          const selected = await context.ui.select(`Choose the Qloo match for \u201C${issue.input.slice(0, 120)}\u201D`, [...labels, cancelLabel]);
+          if (!selected || selected === cancelLabel) {
+            recordQlooResult(event.toolName, event.input, details, context);
+            return;
+          }
+          const selectedIndex = labels.indexOf(selected);
+          const selectedId = issue.candidates[selectedIndex]?.id;
+          if (selectedIndex < 0 || typeof selectedId !== "string") {
+            recordQlooResult(event.toolName, event.input, details, context);
+            return;
+          }
+          choices.push({ input: issue.input, selectedId });
+        }
+        const patchedInput = applyResolutionChoices(event.toolName, event.input, choices);
+        if (!patchedInput) {
+          recordQlooResult(event.toolName, event.input, details, context);
+          return;
+        }
+        try {
+          context.ui.setWorkingMessage("Qloo \xB7 applying your selection\u2026");
+          const retriedDetails = await commandActions.retry(event.toolName, patchedInput);
+          recordQlooResult(event.toolName, patchedInput, retriedDetails, context);
+          await maybeRunAutomaticDiagnosis(retriedDetails, context);
+          return {
+            content: [{ type: "text", text: JSON.stringify(retriedDetails) }],
+            details: retriedDetails,
+            isError: false
+          };
+        } catch {
+          context.ui.notify("Qloo could not rerun the workflow with that selection. The original ambiguity is preserved.", "error");
+          recordQlooResult(event.toolName, event.input, details, context);
+          return;
+        } finally {
+          context.ui.setWorkingMessage();
+        }
+      });
+      pi.on("tool_call", async (event, context) => {
+        const definition = activeDefinition();
+        if (!activeAllowedToolNames().has(event.toolName)) {
+          return {
+            block: true,
+            reason: `Tool "${event.toolName}" is unavailable in Qloo's ${activeProfile} profile.`
+          };
+        }
+        toolCallsThisTurn += 1;
+        if (toolCallsThisTurn > definition.maxToolCallsPerTurn) {
+          return {
+            block: true,
+            terminate: true,
+            reason: `Qloo stopped this turn after ${definition.maxToolCallsPerTurn} tool calls. Summarize progress or ask the user before continuing.`
+          };
+        }
+        const signature = stableToolSignature(event.toolName, event.input);
+        const identicalCount = (identicalCallsThisTurn.get(signature) ?? 0) + 1;
+        identicalCallsThisTurn.set(signature, identicalCount);
+        if (identicalCount > definition.maxIdenticalToolCallsPerTurn) {
+          return {
+            block: true,
+            terminate: true,
+            reason: `Qloo stopped a repeated ${event.toolName} call with unchanged input. Inspect the previous result or ask the user before retrying.`
+          };
+        }
+        if (!new Set(definition.approvalTools).has(event.toolName))
+          return void 0;
+        if (!context.hasUI) {
+          return {
+            block: true,
+            reason: `Tool "${event.toolName}" requires interactive approval in Qloo's ${activeProfile} profile.`
+          };
+        }
+        const approved = await context.ui.confirm(`Approve ${event.toolName}`, safeApprovalDetail(event.toolName, event.input));
+        return approved ? void 0 : {
+          block: true,
+          reason: `User denied ${event.toolName} in Qloo's ${activeProfile} profile.`
+        };
+      });
+      pi.on("user_bash", () => {
+        if (activeDefinition().allowDirectShell)
+          return void 0;
+        return {
+          result: {
+            output: `Direct shell execution is unavailable in Qloo's ${activeProfile} profile. Use qloo integrate or qloo build.
+`,
+            exitCode: 1,
+            cancelled: false,
+            truncated: false
+          }
+        };
+      });
+    }
+  };
+}
+function createExplorePolicyExtension(allowedToolNames) {
+  return createHarnessPolicyExtension("explore", allowedToolNames);
+}
+export {
+  QLOO_SESSION_STATE_ENTRY_TYPE,
+  QLOO_SESSION_STATE_SCHEMA_VERSION,
+  QLOO_WORKSPACE_TOOL_NAMES,
+  buildExploreToolNames,
+  buildProfileToolNames,
+  createExplorePolicyExtension,
+  createHarnessPolicyExtension,
+  validateExploreTools
+};