@iowarp/clio-coder 0.4.5 → 0.4.7

package/src/worker/context-seed.ts

@@ -0,0 +1,192 @@
+/** Pure Pi message seed contract shared by the host and subprocess. No domain runtime or protected engine graph is loaded. */
+
+import { createHash } from "node:crypto";
+import type { WorkerContextProvenance, WorkerContextSeed } from "../domains/context/worker/contract.js";
+import type { AgentMessage } from "../engine/types.js";
+import { canonicalJson } from "./protocol.js";
+
+export const WORKER_CONTEXT_MAX_BYTES = 512 * 1024;
+
+function record(value: unknown): value is Record<string, unknown> {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+export function parseWorkerContextProvenance(value: unknown): WorkerContextProvenance {
+	const fail = (): never => {
+		throw new Error("worker context: malformed provenance");
+	};
+	if (!record(value)) return fail();
+	const p = value;
+	const fields = [
+		"version",
+		"mode",
+		"source",
+		"snapshotHash",
+		"contentHash",
+		"messageCount",
+		"estimatedTokens",
+		"bytes",
+		"omittedMessages",
+		"excludedTailMessages",
+		"excludedInterruptedMessages",
+		"selectedRefs",
+	];
+	if (Object.keys(p).some((key) => !fields.includes(key))) fail();
+	if (p.version !== 1 || (p.mode !== "fork" && p.mode !== "splice") || !record(p.source)) fail();
+	const source = p.source as Record<string, unknown>;
+	if (Object.keys(source).some((key) => !["sessionId", "leafTurnId", "cwd"].includes(key))) fail();
+	if (
+		typeof source.sessionId !== "string" ||
+		!source.sessionId ||
+		typeof source.cwd !== "string" ||
+		!source.cwd ||
+		(source.leafTurnId !== null && typeof source.leafTurnId !== "string")
+	)
+		fail();
+	for (const key of ["snapshotHash", "contentHash"] as const)
+		if (typeof p[key] !== "string" || !/^[a-f0-9]{64}$/u.test(p[key])) fail();
+	for (const key of [
+		"messageCount",
+		"estimatedTokens",
+		"bytes",
+		"omittedMessages",
+		"excludedTailMessages",
+		"excludedInterruptedMessages",
+	])
+		if (!Number.isSafeInteger(p[key]) || (p[key] as number) < 0) fail();
+	if (
+		!Array.isArray(p.selectedRefs) ||
+		p.selectedRefs.some((ref) => typeof ref !== "string" || !/^(tool:.+|message:[0-9]+)$/u.test(ref)) ||
+		new Set(p.selectedRefs).size !== p.selectedRefs.length
+	)
+		fail();
+	return structuredClone(p) as unknown as WorkerContextProvenance;
+}
+
+/** Validate at both host admission and the worker wire boundary before any model invocation. */
+export function parseWorkerContextSeed(value: unknown): WorkerContextSeed {
+	const fail = (): never => {
+		throw new Error("worker context: malformed or digest-mismatched seed");
+	};
+	if (Buffer.byteLength(JSON.stringify(value) ?? "", "utf8") > WORKER_CONTEXT_MAX_BYTES) fail();
+	if (!record(value) || !record(value.provenance) || !Array.isArray(value.messages)) return fail();
+	const p = parseWorkerContextProvenance(value.provenance);
+	for (const message of value.messages) {
+		if (
+			!record(message) ||
+			!["user", "assistant", "toolResult"].includes(String(message.role)) ||
+			!Number.isFinite(message.timestamp)
+		)
+			fail();
+		if (message.role === "user" && typeof message.content === "string") continue;
+		if (!Array.isArray(message.content)) return fail();
+		for (const block of message.content) {
+			if (!record(block)) return fail();
+			switch (block.type) {
+				case "text":
+					if (typeof block.text !== "string") fail();
+					break;
+				case "thinking":
+					if (message.role !== "assistant" || typeof block.thinking !== "string") fail();
+					break;
+				case "image":
+					if (message.role === "assistant" || typeof block.data !== "string" || typeof block.mimeType !== "string") fail();
+					break;
+				case "toolCall":
+					if (
+						message.role !== "assistant" ||
+						typeof block.id !== "string" ||
+						typeof block.name !== "string" ||
+						!record(block.arguments)
+					)
+						fail();
+					break;
+				default:
+					fail();
+			}
+		}
+		if (
+			message.role === "toolResult" &&
+			(typeof message.toolCallId !== "string" ||
+				typeof message.toolName !== "string" ||
+				typeof message.isError !== "boolean")
+		)
+			fail();
+		if (message.role === "assistant") {
+			if (!["stop", "length", "toolUse"].includes(String(message.stopReason))) fail();
+			if (
+				(message.api !== undefined && typeof message.api !== "string") ||
+				(message.provider !== undefined && typeof message.provider !== "string") ||
+				(message.model !== undefined && typeof message.model !== "string") ||
+				(message.usage !== undefined && !record(message.usage))
+			)
+				return fail();
+			if (record(message.usage)) {
+				for (const field of ["input", "output", "cacheRead", "cacheWrite", "totalTokens"])
+					if (
+						message.usage[field] !== undefined &&
+						(typeof message.usage[field] !== "number" || !Number.isFinite(message.usage[field]) || message.usage[field] < 0)
+					)
+						fail();
+			}
+		}
+	}
+	const seed = value as unknown as WorkerContextSeed;
+	completeHistoryLength(seed.messages);
+	if (p.mode === "splice" && (seed.messages.length !== 1 || seed.messages[0]?.role !== "user")) fail();
+	const { contentHash: digest, ...identity } = seed.provenance;
+	if (
+		contextHash({ ...identity, messages: seed.messages }) !== digest ||
+		p.messageCount !== seed.messages.length ||
+		p.bytes !== Buffer.byteLength(JSON.stringify(seed.messages), "utf8")
+	)
+		fail();
+	return structuredClone(seed);
+}
+
+export function seededWorkerMessages(seed: WorkerContextSeed | undefined): AgentMessage[] {
+	if (seed === undefined) return [];
+	const parsed = parseWorkerContextSeed(seed);
+	return parsed.provenance.mode === "fork" ? parsed.messages : [];
+}
+
+export function contextHash(value: unknown): string {
+	return createHash("sha256")
+		.update(`clio-coder.worker-context:1:${canonicalJson(value)}`)
+		.digest("hex");
+}
+
+export function messageToolCalls(
+	message: AgentMessage,
+): Array<{ id: string; name: string; arguments: Record<string, unknown> }> {
+	if (message.role !== "assistant") return [];
+	return message.content.filter((block) => block.type === "toolCall");
+}
+
+/** Validate complete batches. Only a final unfinished batch can be cut at capture. */
+export function completeHistoryLength(messages: ReadonlyArray<AgentMessage>, allowPendingTail = false): number {
+	let batchStart = -1;
+	const pending = new Set<string>();
+	const seen = new Set<string>();
+	for (const [index, message] of messages.entries()) {
+		if (message.role === "toolResult") {
+			if (!pending.delete(message.toolCallId)) throw new Error("worker context: orphaned or duplicate tool result");
+			continue;
+		}
+		if (pending.size > 0) throw new Error("worker context: incomplete historical tool batch");
+		if (message.role !== "user" && message.role !== "assistant")
+			throw new Error("worker context: unsupported message role");
+		if (message.role === "assistant" && (message.stopReason === "error" || message.stopReason === "aborted"))
+			throw new Error("worker context: interrupted assistant message cannot seed a worker");
+		const calls = messageToolCalls(message);
+		if (calls.length > 0) batchStart = index;
+		for (const call of calls) {
+			if (!call.id || seen.has(call.id)) throw new Error("worker context: duplicate or empty tool call id");
+			seen.add(call.id);
+			pending.add(call.id);
+		}
+	}
+	if (pending.size === 0) return messages.length;
+	if (allowPendingTail) return batchStart;
+	throw new Error("worker context: seed contains an unfinished tool batch");
+}

package/src/worker/entry.ts

@@ -179,6 +179,7 @@ async function main(): Promise<number> {
 
 	const input: WorkerRunInput = {
 		systemPrompt: spec.systemPrompt,
+		...(spec.contextSeed ? { contextSeed: spec.contextSeed } : {}),
 		dynamicPromptMessages: spec.dynamicPromptMessages ?? [],
 		agentId: spec.agentId,
 		task: spec.task,

package/src/worker/spec-contract.ts

@@ -4,6 +4,7 @@ import { assertValidResponseSchema, runtimeSpeaksResponseSchemaDialect } from ".
 import type { ToolName } from "../core/tool-names.js";
 import type { ResultContract } from "../domains/agents/result-contract.js";
 import type { AgentProduct } from "../domains/agents/spec.js";
+import type { WorkerContextSeed } from "../domains/context/worker/contract.js";
 import type { MiddlewareSnapshot } from "../domains/middleware/index.js";
 import type {
 	CapabilityFlags,
@@ -18,9 +19,10 @@ import type {
 import type { AutonomyLevel } from "../domains/safety/autonomy.js";
 import type { ProtectedArtifact } from "../domains/safety/protected-artifacts.js";
 import type { ToolProfileName } from "../tools/profiles.js";
+import { parseWorkerContextSeed } from "./context-seed.js";
 
 /** Current attested, budget-bearing dispatch document emitted by this release. */
-export const WORKER_SPEC_VERSION = 3;
+export const WORKER_SPEC_VERSION = 4;
 export const WORKER_RUNTIME_DESCRIPTOR_VERSION = 2;
 export const WORKER_PROTECTED_ARTIFACT_STATE_VERSION = 1;
 
@@ -77,6 +79,7 @@ interface WorkerSpecFields {
 	 */
 	settingsFingerprint: string;
 	systemPrompt: string;
+	contextSeed?: WorkerContextSeed;
 	dynamicPromptMessages?: ReadonlyArray<WorkerPromptMessage>;
 	promptSignature?: string;
 	toolSignature?: string;
@@ -618,6 +621,10 @@ export function parseWorkerSpec(value: unknown): WorkerSpec {
 	readEnum(runtime.auth, "WorkerSpec.runtime.auth", RUNTIME_AUTHS);
 	readString(spec.systemPrompt, "WorkerSpec.systemPrompt", { allowEmpty: true });
 	readWorkerPromptMessages(spec.dynamicPromptMessages, "WorkerSpec.dynamicPromptMessages");
+	if (spec.contextSeed !== undefined) {
+		parseWorkerContextSeed(spec.contextSeed);
+		if (runtimeKind !== "http") throw new Error("worker context: native history seeds require an HTTP/Pi runtime");
+	}
 	readOptionalString(spec, "promptSignature", "WorkerSpec");
 	readOptionalString(spec, "toolSignature", "WorkerSpec");
 	readOptionalString(spec, "dynamicHash", "WorkerSpec");

package/dist/chunk-3UW3KU4A.js

@@ -1,21 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  init_esm_shims
-} from "./chunk-ECBHH7LU.js";
-
-// src/domains/config/agent-namespace.ts
-init_esm_shims();
-function assertAgentIdNamespace(nativeRecipes, acpDelegates) {
-  const native = new Set(nativeRecipes.map((recipe) => recipe.id));
-  const collision = acpDelegates.find((delegate) => native.has(delegate.id));
-  if (collision !== void 0) {
-    throw new Error(
-      `agent id collision: native recipe '${collision.id}' and ACP delegation agent '${collision.id}' share one namespace`
-    );
-  }
-}
-
-export {
-  assertAgentIdNamespace
-};
-//# sourceMappingURL=chunk-3UW3KU4A.js.map

package/dist/chunk-6SYEGZI3.js

@@ -1,433 +0,0 @@
-import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
-import {
-  readSettings,
-  updateSettings
-} from "./chunk-FKIOX6DS.js";
-import {
-  INTEROP_AGENT_KINDS,
-  interopAgentKind
-} from "./chunk-5CY4Q6QI.js";
-import {
-  runCommandVector
-} from "./chunk-GJ24ODAX.js";
-import {
-  withStateFileLockSync
-} from "./chunk-2QPI3TR3.js";
-import {
-  require_dist
-} from "./chunk-B5GGDIHT.js";
-import {
-  safeResourceWrite
-} from "./chunk-ZZFWWYLX.js";
-import {
-  clioStateDir
-} from "./chunk-CTTI7G3T.js";
-import {
-  __toESM,
-  init_esm_shims
-} from "./chunk-ECBHH7LU.js";
-
-// src/domains/interop/index.ts
-init_esm_shims();
-
-// src/domains/interop/extension.ts
-init_esm_shims();
-
-// src/domains/interop/consent.ts
-init_esm_shims();
-var import_yaml = __toESM(require_dist(), 1);
-
-// src/domains/interop/state.ts
-init_esm_shims();
-import { existsSync, readFileSync } from "node:fs";
-import path from "node:path";
-var KNOWN_IDS = new Set(INTEROP_AGENT_KINDS.map((kind) => kind.id));
-var PRESENCES = /* @__PURE__ */ new Set(["present", "absent", "unknown"]);
-function interopStatePath() {
-  return path.join(clioStateDir(), "interop.json");
-}
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function stringField(raw, key) {
-  const value = raw[key];
-  return typeof value === "string" && value.length > 0 ? value : void 0;
-}
-function countField(raw, key) {
-  const value = raw[key];
-  return typeof value === "number" && Number.isInteger(value) && value >= 0 ? value : 0;
-}
-function presenceField(raw, key) {
-  const value = raw[key];
-  return typeof value === "string" && PRESENCES.has(value) ? value : void 0;
-}
-function parseAgent(raw) {
-  if (!isRecord(raw)) return null;
-  const kind = stringField(raw, "kind");
-  const fingerprint = stringField(raw, "fingerprint");
-  const presence = presenceField(raw, "presence");
-  if (kind === void 0 || !KNOWN_IDS.has(kind) || fingerprint === void 0 || presence === void 0) return null;
-  const decision = stringField(raw, "decision");
-  const adapter = presenceField(raw, "adapter");
-  const binary = stringField(raw, "binary");
-  const version = stringField(raw, "version");
-  const installDir = stringField(raw, "installDir");
-  const decidedAt = stringField(raw, "decidedAt");
-  const decidedFingerprint = stringField(raw, "decidedFingerprint");
-  const hintedFingerprint = stringField(raw, "hintedFingerprint");
-  return {
-    kind,
-    presence,
-    fingerprint,
-    skillCount: countField(raw, "skillCount"),
-    projectArtifacts: countField(raw, "projectArtifacts"),
-    ...binary !== void 0 ? { binary } : {},
-    ...version !== void 0 ? { version } : {},
-    ...installDir !== void 0 ? { installDir } : {},
-    ...adapter !== void 0 ? { adapter } : {},
-    ...decision === "accepted" || decision === "declined" ? { decision } : {},
-    ...decidedAt !== void 0 ? { decidedAt } : {},
-    ...decidedFingerprint !== void 0 ? { decidedFingerprint } : {},
-    ...hintedFingerprint !== void 0 ? { hintedFingerprint } : {}
-  };
-}
-function readInteropReport() {
-  let filePath;
-  try {
-    filePath = interopStatePath();
-  } catch {
-    return null;
-  }
-  if (!existsSync(filePath)) return null;
-  try {
-    const parsed = JSON.parse(readFileSync(filePath, "utf8"));
-    if (!isRecord(parsed) || parsed.version !== 1) return null;
-    const detectedAt = stringField(parsed, "detectedAt");
-    if (detectedAt === void 0 || !Array.isArray(parsed.agents)) return null;
-    const agents = parsed.agents.map(parseAgent).filter((agent) => agent !== null);
-    return { version: 1, detectedAt, agents };
-  } catch {
-    return null;
-  }
-}
-function writeInteropReport(report) {
-  safeResourceWrite(interopStatePath(), `${JSON.stringify(report, null, 2)}
-`, { encoding: "utf8" });
-}
-
-// src/domains/interop/consent.ts
-var INHERITED_PROJECT_CONTEXT = "none";
-function delegationEntryForKind(kind, defaults) {
-  const recipe = kind.acp;
-  if (recipe === void 0) throw new Error(`interop kind ${kind.id} has no ACP recipe`);
-  return {
-    id: kind.id,
-    command: recipe.command,
-    args: [...recipe.args],
-    connectTimeoutMs: defaults.connectTimeoutMs,
-    turnTimeoutMs: defaults.turnTimeoutMs,
-    permissionTimeoutMs: defaults.permissionTimeoutMs,
-    toolGovernance: "clio-coder-policy"
-  };
-}
-function interopProposals(report, settings) {
-  const configured = new Set(settings.integrations.externalAgents.entries.map((agent) => agent.id));
-  const proposals = [];
-  for (const record of report.agents) {
-    const kind = interopAgentKind(record.kind);
-    if (kind?.acp === void 0) continue;
-    if (record.presence !== "present") continue;
-    if (configured.has(kind.id)) continue;
-    if (record.decision !== void 0 && record.decidedFingerprint === record.fingerprint) continue;
-    proposals.push({
-      kind: kind.id,
-      label: kind.label,
-      fingerprint: record.fingerprint,
-      entry: delegationEntryForKind(kind, settings.integrations.externalAgents.defaults),
-      needsNetworkInstall: record.adapter !== "present"
-    });
-  }
-  return proposals;
-}
-function renderProposalEntry(proposal) {
-  return (0, import_yaml.stringify)([proposal.entry]).trimEnd();
-}
-function withStoredDecision(stored, fresh) {
-  if (stored === void 0) return fresh;
-  return {
-    ...fresh,
-    ...stored.decision !== void 0 ? { decision: stored.decision } : {},
-    ...stored.decidedAt !== void 0 ? { decidedAt: stored.decidedAt } : {},
-    ...stored.decidedFingerprint !== void 0 ? { decidedFingerprint: stored.decidedFingerprint } : {},
-    ...stored.hintedFingerprint !== void 0 ? { hintedFingerprint: stored.hintedFingerprint } : {}
-  };
-}
-function updateRecords(ids, report, patch) {
-  const wanted = new Set(ids);
-  const touched = [];
-  withStateFileLockSync(interopStatePath(), () => {
-    const stored = readInteropReport();
-    const storedByKind = new Map(
-      (stored?.agents ?? []).map((record) => [record.kind, record])
-    );
-    const byKind = new Map(storedByKind);
-    for (const record of report.agents) {
-      byKind.set(record.kind, withStoredDecision(storedByKind.get(record.kind), record));
-    }
-    for (const id of wanted) {
-      const record = byKind.get(id);
-      if (record === void 0) continue;
-      byKind.set(id, patch(record));
-      touched.push(id);
-    }
-    writeInteropReport({ version: 1, detectedAt: report.detectedAt, agents: [...byKind.values()] });
-  });
-  return touched;
-}
-function recordDecisions(ids, report, decision) {
-  const decidedAt = (/* @__PURE__ */ new Date()).toISOString();
-  return updateRecords(ids, report, (record) => ({
-    ...record,
-    decision,
-    decidedAt,
-    decidedFingerprint: record.fingerprint
-  }));
-}
-function interopBootHint(report, settings) {
-  const fresh = interopProposals(report, settings).filter(
-    (proposal) => report.agents.find((agent) => agent.kind === proposal.kind)?.hintedFingerprint !== proposal.fingerprint
-  );
-  if (fresh.length === 0) return null;
-  updateRecords(
-    fresh.map((proposal) => proposal.kind),
-    report,
-    (record) => ({ ...record, hintedFingerprint: record.fingerprint })
-  );
-  const names = fresh.map((proposal) => proposal.entry.id).join(", ");
-  return `clio-coder: ${names} detected on PATH and not configured. Run /interop to review.`;
-}
-function acceptInteropAgents(ids, report) {
-  const proposals = interopProposals(report, readSettings()).filter((proposal) => ids.includes(proposal.kind));
-  const diagnostics = [];
-  for (const id of ids) {
-    if (!proposals.some((proposal) => proposal.kind === id)) diagnostics.push(`${id} is not a pending proposal`);
-  }
-  if (proposals.length === 0) return { decided: [], wired: [], diagnostics };
-  const wired = [];
-  updateSettings((settings) => {
-    for (const proposal of proposals) {
-      if (settings.integrations.externalAgents.entries.some((agent) => agent.id === proposal.entry.id)) continue;
-      settings.integrations.externalAgents.entries.push({ ...proposal.entry, args: [...proposal.entry.args] });
-      wired.push(proposal.entry.id);
-    }
-  });
-  const decided = recordDecisions(
-    proposals.map((proposal) => proposal.kind),
-    report,
-    "accepted"
-  );
-  return { decided, wired, diagnostics };
-}
-function declineInteropAgents(ids, report) {
-  return { decided: recordDecisions(ids, report, "declined"), wired: [], diagnostics: [] };
-}
-
-// src/domains/interop/detect.ts
-init_esm_shims();
-import { createHash } from "node:crypto";
-import { accessSync, constants, existsSync as existsSync2 } from "node:fs";
-import { homedir } from "node:os";
-import path2 from "node:path";
-var VERSION_PROBE_TIMEOUT_MS = 2e3;
-var VERSION_PROBE_MAX_OUTPUT_BYTES = 4096;
-function resolveOnPath(binaryNames) {
-  if (binaryNames.length === 0) return { presence: "absent" };
-  const rawPath = process.env.PATH;
-  if (rawPath === void 0 || rawPath.length === 0) return { presence: "unknown" };
-  try {
-    for (const dir of rawPath.split(path2.delimiter)) {
-      if (dir.length === 0) continue;
-      for (const name of binaryNames) {
-        const candidate = path2.join(dir, name);
-        try {
-          accessSync(candidate, constants.X_OK);
-          return { presence: "present", binary: candidate };
-        } catch {
-        }
-      }
-    }
-  } catch {
-    return { presence: "unknown" };
-  }
-  return { presence: "absent" };
-}
-function adapterPresence(kind, cwd, binaryPresence) {
-  const recipe = kind.acp;
-  if (recipe === void 0) return "absent";
-  if (recipe.npmPackage === void 0) return binaryPresence;
-  try {
-    if (existsSync2(path2.join(cwd, "node_modules", recipe.npmPackage))) return "present";
-  } catch {
-    return "unknown";
-  }
-  if (recipe.npmPackageBin === void 0) return "absent";
-  return resolveOnPath([recipe.npmPackageBin]).presence;
-}
-function installDirOf(kind, home) {
-  const dir = path2.join(home, kind.userDir);
-  try {
-    return existsSync2(dir) ? dir : void 0;
-  } catch {
-    return void 0;
-  }
-}
-function parseVersion(output) {
-  return /\b\d+\.\d+(?:\.\d+)?(?:[-+][0-9A-Za-z.-]+)?\b/.exec(output)?.[0];
-}
-async function probeVersion(binary, cwd) {
-  try {
-    const result = await runCommandVector(binary, ["--version"], {
-      cwd,
-      workspaceRoot: cwd,
-      timeoutMs: VERSION_PROBE_TIMEOUT_MS,
-      maxOutputBytes: VERSION_PROBE_MAX_OUTPUT_BYTES
-    });
-    if (result.timedOut || result.exitCode !== 0) return void 0;
-    return parseVersion(`${result.stdout}
-${result.stderr}`);
-  } catch {
-    return void 0;
-  }
-}
-function interopFingerprint(kind, facts) {
-  const recipe = kind.acp;
-  const parts = [
-    kind.id,
-    facts.binary ?? "",
-    facts.version ?? "",
-    recipe === void 0 ? "" : `${recipe.command} ${recipe.args.join(" ")}`
-  ];
-  return `sha256:${createHash("sha256").update(parts.join("\0")).digest("hex")}`;
-}
-function countBy(values, match) {
-  if (values === void 0 || match === void 0) return 0;
-  return values.filter((value) => value === match).length;
-}
-function detected(facts) {
-  return facts.presence === "present" || facts.installDir !== void 0 || facts.skillCount > 0 || facts.projectArtifacts > 0;
-}
-async function detectInteropAgents(input = {}, previous) {
-  const cwd = path2.resolve(input.cwd ?? process.cwd());
-  const home = input.home ?? homedir();
-  const priorByKind = new Map((previous ?? readInteropReport()?.agents ?? []).map((record) => [record.kind, record]));
-  const agents = [];
-  for (const kind of INTEROP_AGENT_KINDS) {
-    const resolved = resolveOnPath(kind.binaryNames);
-    const prior = priorByKind.get(kind.id);
-    const installDir = installDirOf(kind, home);
-    const facts = {
-      kind: kind.id,
-      presence: resolved.presence,
-      ...resolved.binary !== void 0 ? { binary: resolved.binary } : {},
-      ...installDir !== void 0 ? { installDir } : {},
-      ...kind.acp !== void 0 ? { adapter: adapterPresence(kind, cwd, resolved.presence) } : {},
-      skillCount: countBy(input.skillSources, kind.skillSource),
-      projectArtifacts: countBy(input.artifactProviders, kind.adoptionProvider)
-    };
-    if (resolved.binary !== void 0) {
-      const version = input.probeVersion === true ? await probeVersion(resolved.binary, cwd) : (
-        // A run that did not probe keeps the last version seen for the same
-        // binary, so the fingerprint does not flip between probing callers.
-        prior?.binary === resolved.binary ? prior.version : void 0
-      );
-      if (version !== void 0) facts.version = version;
-    }
-    if (!detected(facts)) continue;
-    agents.push({
-      ...facts,
-      fingerprint: interopFingerprint(kind, facts),
-      ...prior?.decision !== void 0 ? { decision: prior.decision } : {},
-      ...prior?.decidedAt !== void 0 ? { decidedAt: prior.decidedAt } : {},
-      ...prior?.decidedFingerprint !== void 0 ? { decidedFingerprint: prior.decidedFingerprint } : {},
-      ...prior?.hintedFingerprint !== void 0 ? { hintedFingerprint: prior.hintedFingerprint } : {}
-    });
-  }
-  return { version: 1, detectedAt: (/* @__PURE__ */ new Date()).toISOString(), agents };
-}
-
-// src/domains/interop/extension.ts
-var EMPTY_REPORT = { version: 1, detectedAt: (/* @__PURE__ */ new Date(0)).toISOString(), agents: [] };
-function createInteropBundle(_context) {
-  let detected2 = null;
-  const extension = {
-    start() {
-      return void 0;
-    }
-  };
-  const contract = {
-    kinds() {
-      return INTEROP_AGENT_KINDS;
-    },
-    async detect(input = {}) {
-      detected2 = await detectInteropAgents(input, detected2?.agents);
-      return detected2;
-    },
-    // A decision is written and read back, so the report an overlay rebuilds
-    // from carries it: a declined row leaves the proposal list on the
-    // keystroke rather than on the next detection.
-    lastReport() {
-      return detected2 ?? readInteropReport();
-    },
-    proposals(report) {
-      return interopProposals(report, readSettings());
-    },
-    // Read here, not from the hot settings snapshot the TUI holds: that one is
-    // refreshed by the config watcher a tick after the write, and the overlay
-    // rebuilds its rows the moment accept returns. An accepted peer was gone
-    // from the proposals, which read the file, and not yet in the configured
-    // list, which read the snapshot, so it was in neither until a reopen.
-    configured() {
-      return readSettings().integrations.externalAgents.entries;
-    },
-    accept(ids) {
-      const result = acceptInteropAgents(ids, detected2 ?? readInteropReport() ?? EMPTY_REPORT);
-      detected2 = readInteropReport() ?? detected2;
-      return result;
-    },
-    decline(ids) {
-      const result = declineInteropAgents(ids, detected2 ?? readInteropReport() ?? EMPTY_REPORT);
-      detected2 = readInteropReport() ?? detected2;
-      return result;
-    },
-    bootHint(report) {
-      return interopBootHint(report, readSettings());
-    }
-  };
-  return { extension, contract };
-}
-
-// src/domains/interop/manifest.ts
-init_esm_shims();
-var InteropManifest = {
-  name: "interop",
-  dependsOn: ["config"]
-};
-
-// src/domains/interop/index.ts
-var InteropDomainModule = {
-  manifest: InteropManifest,
-  createExtension: createInteropBundle
-};
-
-export {
-  INHERITED_PROJECT_CONTEXT,
-  delegationEntryForKind,
-  interopProposals,
-  renderProposalEntry,
-  acceptInteropAgents,
-  declineInteropAgents,
-  resolveOnPath,
-  detectInteropAgents,
-  InteropDomainModule
-};
-//# sourceMappingURL=chunk-6SYEGZI3.js.map