@zigil/agent-react 0.1.0

package/dist/index.js

@@ -0,0 +1,1078 @@
+// src/attention.tsx
+import {
+  createContext,
+  createElement,
+  useContext
+} from "react";
+var MAX_SERIALIZED_BYTES = 4 * 1024;
+var MAX_REQUIRED_FIELD_LENGTH = 128;
+var MAX_SELECTIONS = 12;
+var MAX_HISTORY = 40;
+var MAX_FOCUSED_HISTORY = 8;
+var MAX_HOVER_HISTORY = 2;
+var ATTENTION_ACTIVITY_ACTIONS = [
+  "focus",
+  "select",
+  "navigate",
+  "edit",
+  "execute",
+  "approve",
+  "dismiss",
+  "hover"
+];
+var AttentionContextReact = createContext(null);
+function AttentionProvider({
+  children,
+  context
+}) {
+  return createElement(
+    AttentionContextReact.Provider,
+    { value: context },
+    children
+  );
+}
+function useAttention() {
+  return useContext(AttentionContextReact);
+}
+function formatAttentionLabel(attention) {
+  const primary = attention?.selection?.label ?? attention?.selection?.id ?? attention?.workspace?.label ?? "this workspace";
+  const extraSelections = Math.max(0, (attention?.selections?.length ?? 0) - 1);
+  return extraSelections > 0 ? `${primary} +${extraSelections}` : primary;
+}
+var AttentionContextSchema = standardSchema(
+  (value) => {
+    const issues = validateAttentionContext(value);
+    return issues.length > 0 ? issues : value;
+  }
+);
+function serializeAttention(context, privacy = "focused") {
+  const normalized = normalizeAttention(context, privacy);
+  assertClosedAttention(normalized);
+  let serialized = JSON.stringify(normalized);
+  if (byteLength(serialized) <= MAX_SERIALIZED_BYTES) return serialized;
+  warnOversizedAttention();
+  while (normalized.history?.some((event) => event.action === "hover")) {
+    const hoverIndex = normalized.history.findIndex(
+      (event) => event.action === "hover"
+    );
+    normalized.history.splice(hoverIndex, 1);
+    if (normalized.history.length === 0) delete normalized.history;
+    serialized = JSON.stringify(normalized);
+    if (byteLength(serialized) <= MAX_SERIALIZED_BYTES) return serialized;
+  }
+  while ((normalized.history?.length ?? 0) > 0) {
+    normalized.history?.shift();
+    if (normalized.history?.length === 0) delete normalized.history;
+    serialized = JSON.stringify(normalized);
+    if (byteLength(serialized) <= MAX_SERIALIZED_BYTES) return serialized;
+  }
+  delete normalized.hover;
+  serialized = JSON.stringify(normalized);
+  if (byteLength(serialized) <= MAX_SERIALIZED_BYTES) return serialized;
+  removeOptionalSelectionFields(normalized);
+  serialized = JSON.stringify(normalized);
+  if (byteLength(serialized) <= MAX_SERIALIZED_BYTES) return serialized;
+  const required = truncateRequiredFields(normalized);
+  serialized = JSON.stringify(required);
+  while (byteLength(serialized) > MAX_SERIALIZED_BYTES && (required.selections?.length ?? 0) > 0) {
+    required.selections?.pop();
+    if (required.selections?.length === 0) delete required.selections;
+    serialized = JSON.stringify(required);
+  }
+  return serialized;
+}
+function validateAttentionContext(value, path = []) {
+  if (!isRecord(value)) return [issue("Expected attention context", ...path)];
+  const issues = [];
+  if (!hasOnlyKeys(value, [
+    "application",
+    "route",
+    "workspace",
+    "selection",
+    "selections",
+    "hover",
+    "history"
+  ]))
+    issues.push(issue("Unexpected attention field", ...path));
+  if (typeof value.application !== "string")
+    issues.push(issue("Expected a string", ...path, "application"));
+  if (typeof value.route !== "string")
+    issues.push(issue("Expected a string", ...path, "route"));
+  if (value.workspace !== void 0)
+    issues.push(...validateWorkspace(value.workspace, [...path, "workspace"]));
+  if (value.selection !== void 0)
+    issues.push(...validateSelection(value.selection, [...path, "selection"]));
+  if (value.hover !== void 0)
+    issues.push(...validateSelection(value.hover, [...path, "hover"]));
+  if (value.selections !== void 0) {
+    if (!Array.isArray(value.selections))
+      issues.push(issue("Expected selections", ...path, "selections"));
+    else
+      value.selections.forEach(
+        (selection, index) => issues.push(
+          ...validateSelection(selection, [...path, "selections", index])
+        )
+      );
+  }
+  if (value.history !== void 0) {
+    if (!Array.isArray(value.history))
+      issues.push(issue("Expected activity history", ...path, "history"));
+    else
+      value.history.forEach(
+        (event, index) => issues.push(...validateActivity(event, [...path, "history", index]))
+      );
+  }
+  return issues;
+}
+function normalizeAttention(context, privacy) {
+  const workspace = context.workspace ? {
+    kind: context.workspace.kind,
+    id: context.workspace.id,
+    ...context.workspace.revision === void 0 ? {} : { revision: context.workspace.revision },
+    ...privacy === "minimal" || context.workspace.label === void 0 ? {} : { label: context.workspace.label }
+  } : void 0;
+  const primary = context.selection ? normalizeSelection(context.selection, privacy !== "minimal") : void 0;
+  if (privacy === "minimal") {
+    return {
+      application: context.application,
+      route: context.route,
+      ...workspace ? { workspace } : {},
+      ...primary ? { selection: primary } : {}
+    };
+  }
+  const selections = normalizeSelections(context.selections, primary);
+  const history = normalizeHistory(
+    context.history,
+    privacy === "focused" ? MAX_FOCUSED_HISTORY : MAX_HISTORY,
+    privacy === "expanded"
+  );
+  return {
+    application: context.application,
+    route: context.route,
+    ...workspace ? { workspace } : {},
+    ...primary ? { selection: primary } : {},
+    ...selections.length > 0 ? { selections } : {},
+    ...privacy === "expanded" && context.hover ? { hover: normalizeSelection(context.hover, true) } : {},
+    ...history.length > 0 ? { history } : {}
+  };
+}
+function normalizeSelections(selections, primary) {
+  const ordered = primary ? [
+    primary,
+    ...(selections ?? []).map((item) => normalizeSelection(item, true))
+  ] : (selections ?? []).map((item) => normalizeSelection(item, true));
+  const seen = /* @__PURE__ */ new Set();
+  return ordered.filter((item) => {
+    const key = selectionKey(item);
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  }).slice(0, MAX_SELECTIONS);
+}
+function normalizeHistory(history, limit, includeHover) {
+  const semantic = [];
+  const hovers = [];
+  for (const event of history ?? []) {
+    const normalized = normalizeEvent(event);
+    if (normalized.action !== "hover") semantic.push(normalized);
+    else if (includeHover) {
+      const previous = hovers.at(-1);
+      if (previous && selectionKey(previous.target) === selectionKey(normalized.target))
+        hovers[hovers.length - 1] = normalized;
+      else hovers.push(normalized);
+    }
+  }
+  const retainedSemantic = semantic.slice(-limit);
+  const remaining = Math.max(0, limit - retainedSemantic.length);
+  const hoverLimit = Math.min(MAX_HOVER_HISTORY, remaining);
+  const retainedHover = hoverLimit > 0 ? hovers.slice(-hoverLimit) : [];
+  return [...retainedSemantic, ...retainedHover].sort(
+    (left, right) => left.timestamp - right.timestamp
+  );
+}
+function normalizeEvent(event) {
+  return {
+    action: event.action,
+    target: normalizeSelection(event.target, true),
+    timestamp: event.timestamp,
+    ...event.summary === void 0 ? {} : { summary: event.summary },
+    ...event.detail === void 0 ? {} : { detail: sortRecord(event.detail) }
+  };
+}
+function normalizeSelection(selection, includeOptional) {
+  return {
+    kind: selection.kind,
+    id: selection.id,
+    ...includeOptional && selection.label !== void 0 ? { label: selection.label } : {},
+    ...includeOptional && selection.detail !== void 0 ? { detail: sortRecord(selection.detail) } : {}
+  };
+}
+function removeOptionalSelectionFields(context) {
+  const selections = [
+    context.selection,
+    ...context.selections ?? [],
+    context.hover
+  ].filter((selection) => Boolean(selection));
+  for (const selection of selections.reverse()) {
+    for (const key of Object.keys(selection.detail ?? {}).reverse()) {
+      if (!selection.detail) break;
+      delete selection.detail[key];
+      if (Object.keys(selection.detail).length === 0) delete selection.detail;
+    }
+    delete selection.label;
+  }
+  if (context.workspace) delete context.workspace.label;
+}
+function truncateRequiredFields(context) {
+  return {
+    application: truncateText(context.application),
+    route: truncateText(context.route),
+    ...context.workspace ? {
+      workspace: {
+        kind: truncateText(context.workspace.kind),
+        id: truncateText(context.workspace.id),
+        ...context.workspace.revision === void 0 ? {} : { revision: context.workspace.revision }
+      }
+    } : {},
+    ...context.selection ? {
+      selection: {
+        kind: truncateText(context.selection.kind),
+        id: truncateText(context.selection.id)
+      }
+    } : {},
+    ...context.selections ? {
+      selections: context.selections.slice(0, MAX_SELECTIONS).map((item) => ({
+        kind: truncateText(item.kind),
+        id: truncateText(item.id)
+      }))
+    } : {}
+  };
+}
+function validateWorkspace(value, path) {
+  if (!isRecord(value)) return [issue("Expected a workspace", ...path)];
+  const issues = [];
+  if (!hasOnlyKeys(value, ["kind", "id", "label", "revision"]))
+    issues.push(issue("Unexpected workspace field", ...path));
+  for (const key of ["kind", "id"])
+    if (typeof value[key] !== "string")
+      issues.push(issue("Expected a string", ...path, key));
+  if (value.label !== void 0 && typeof value.label !== "string")
+    issues.push(issue("Expected a string", ...path, "label"));
+  if (value.revision !== void 0 && (typeof value.revision !== "number" || !Number.isFinite(value.revision)))
+    issues.push(issue("Expected a finite revision", ...path, "revision"));
+  return issues;
+}
+function validateSelection(value, path) {
+  if (!isRecord(value)) return [issue("Expected a selection", ...path)];
+  const issues = [];
+  if (!hasOnlyKeys(value, ["kind", "id", "label", "detail"]))
+    issues.push(issue("Unexpected selection field", ...path));
+  for (const key of ["kind", "id"])
+    if (typeof value[key] !== "string")
+      issues.push(issue("Expected a string", ...path, key));
+  if (value.label !== void 0 && typeof value.label !== "string")
+    issues.push(issue("Expected a string", ...path, "label"));
+  issues.push(...validateStringRecord(value.detail, [...path, "detail"]));
+  return issues;
+}
+function validateActivity(value, path) {
+  if (!isRecord(value)) return [issue("Expected activity", ...path)];
+  const issues = [];
+  if (!hasOnlyKeys(value, ["action", "target", "timestamp", "summary", "detail"]))
+    issues.push(issue("Unexpected activity field", ...path));
+  if (typeof value.action !== "string" || !ATTENTION_ACTIVITY_ACTIONS.includes(
+    value.action
+  ))
+    issues.push(issue("Expected an action", ...path, "action"));
+  if (typeof value.timestamp !== "number" || !Number.isFinite(value.timestamp))
+    issues.push(issue("Expected a finite timestamp", ...path, "timestamp"));
+  if (value.summary !== void 0 && typeof value.summary !== "string")
+    issues.push(issue("Expected a string", ...path, "summary"));
+  issues.push(...validateSelection(value.target, [...path, "target"]));
+  issues.push(...validateStringRecord(value.detail, [...path, "detail"]));
+  return issues;
+}
+function validateStringRecord(value, path) {
+  if (value === void 0) return [];
+  if (!isRecord(value) || !Object.values(value).every((item) => typeof item === "string"))
+    return [issue("Expected string details", ...path)];
+  return [];
+}
+function assertClosedAttention(value) {
+  const issues = validateAttentionContext(value);
+  if (issues.length > 0)
+    throw new Error(`Invalid attention serialization: ${issues[0]?.message}`);
+}
+function standardSchema(validate) {
+  return {
+    "~standard": {
+      version: 1,
+      vendor: "sigil-agent",
+      validate(value) {
+        const result = validate(value);
+        return Array.isArray(result) ? { issues: result } : { value: result };
+      }
+    }
+  };
+}
+function issue(message, ...path) {
+  return { message, path };
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOnlyKeys(value, allowed) {
+  const keys = new Set(allowed);
+  return Object.keys(value).every((key) => keys.has(key));
+}
+function sortRecord(record) {
+  return Object.fromEntries(
+    Object.entries(record).sort(([left], [right]) => left.localeCompare(right))
+  );
+}
+function selectionKey(selection) {
+  return `${selection.kind}\0${selection.id}`;
+}
+function truncateText(value) {
+  return value.length <= MAX_REQUIRED_FIELD_LENGTH ? value : `${value.slice(0, MAX_REQUIRED_FIELD_LENGTH - 1)}\u2026`;
+}
+function byteLength(value) {
+  return new TextEncoder().encode(value).byteLength;
+}
+function warnOversizedAttention() {
+  const isDevelopment = import.meta.env?.DEV === true;
+  if (isDevelopment)
+    console.warn(
+      "Agent attention exceeded 4 KB; optional context was removed before sending."
+    );
+}
+
+// src/attention-telemetry.ts
+import { useCallback, useEffect, useReducer, useRef } from "react";
+var DEFAULT_HOVER_DELAY_MS = 500;
+var DEFAULT_HISTORY_LIMIT = 40;
+function createAttentionTelemetryState(initialSelections = []) {
+  return {
+    selections: deduplicateTargets(initialSelections),
+    history: []
+  };
+}
+function reduceAttentionTelemetry(state, action) {
+  switch (action.type) {
+    case "select": {
+      const exists = state.selections.some(
+        (item) => sameAttentionTarget(item, action.target)
+      );
+      const selections = action.mode === "replace" ? [action.target] : exists ? state.selections.filter(
+        (item) => !sameAttentionTarget(item, action.target)
+      ) : [action.target, ...state.selections];
+      return {
+        ...state,
+        selections,
+        history: appendBoundedActivity(
+          state.history,
+          action.event,
+          action.historyLimit
+        )
+      };
+    }
+    case "record":
+      return {
+        ...state,
+        history: appendBoundedActivity(
+          state.history,
+          action.event,
+          action.historyLimit
+        )
+      };
+    case "hover":
+      return {
+        ...state,
+        hover: action.target,
+        history: appendBoundedActivity(
+          state.history,
+          action.event,
+          action.historyLimit
+        )
+      };
+    case "end-hover": {
+      const { hover: _hover, ...withoutHover } = state;
+      return withoutHover;
+    }
+    case "clear-selections":
+      return { ...state, selections: [] };
+    case "clear-history":
+      return { ...state, history: [] };
+  }
+}
+function useAttentionTelemetry({
+  initialSelections = [],
+  hoverDelayMs = DEFAULT_HOVER_DELAY_MS,
+  historyLimit = DEFAULT_HISTORY_LIMIT
+} = {}) {
+  const [state, dispatch] = useReducer(
+    reduceAttentionTelemetry,
+    initialSelections,
+    createAttentionTelemetryState
+  );
+  const hoverTimer = useRef(
+    void 0
+  );
+  const hoverTarget = useRef(void 0);
+  useEffect(
+    () => () => {
+      if (hoverTimer.current) clearTimeout(hoverTimer.current);
+    },
+    []
+  );
+  const recordActivity = useCallback(
+    (action, target, options = {}) => {
+      dispatch({
+        type: "record",
+        event: createActivity(action, target, options),
+        historyLimit
+      });
+    },
+    [historyLimit]
+  );
+  const select = useCallback(
+    (target) => {
+      dispatch({
+        type: "select",
+        target,
+        mode: "replace",
+        event: createActivity("select", target),
+        historyLimit
+      });
+    },
+    [historyLimit]
+  );
+  const toggleSelection = useCallback(
+    (target) => {
+      dispatch({
+        type: "select",
+        target,
+        mode: "toggle",
+        event: createActivity("select", target),
+        historyLimit
+      });
+    },
+    [historyLimit]
+  );
+  const clearSelections = useCallback(
+    () => dispatch({ type: "clear-selections" }),
+    []
+  );
+  const beginHover = useCallback(
+    (target) => {
+      if (hoverTimer.current) clearTimeout(hoverTimer.current);
+      hoverTarget.current = target;
+      hoverTimer.current = setTimeout(() => {
+        if (!hoverTarget.current || !sameAttentionTarget(hoverTarget.current, target))
+          return;
+        dispatch({
+          type: "hover",
+          target,
+          event: createActivity("hover", target),
+          historyLimit
+        });
+      }, hoverDelayMs);
+    },
+    [historyLimit, hoverDelayMs]
+  );
+  const endHover = useCallback((target) => {
+    if (target && hoverTarget.current && !sameAttentionTarget(target, hoverTarget.current))
+      return;
+    if (hoverTimer.current) clearTimeout(hoverTimer.current);
+    hoverTimer.current = void 0;
+    hoverTarget.current = void 0;
+    dispatch({ type: "end-hover" });
+  }, []);
+  const clearHistory = useCallback(
+    () => dispatch({ type: "clear-history" }),
+    []
+  );
+  return {
+    selection: state.selections[0],
+    selections: state.selections,
+    hover: state.hover,
+    history: state.history,
+    select,
+    toggleSelection,
+    clearSelections,
+    beginHover,
+    endHover,
+    recordActivity,
+    clearHistory
+  };
+}
+function appendBoundedActivity(history, event, limit = DEFAULT_HISTORY_LIMIT) {
+  const withoutDuplicateHover = event.action === "hover" ? history.filter(
+    (item) => item.action !== "hover" || !sameAttentionTarget(item.target, event.target)
+  ) : [...history];
+  const next = [...withoutDuplicateHover, event];
+  const hoverIndexes = next.map((item, index) => item.action === "hover" ? index : -1).filter((index) => index >= 0);
+  for (const index of hoverIndexes.slice(0, -2).reverse())
+    next.splice(index, 1);
+  while (next.length > Math.max(0, limit)) {
+    const firstHover = next.findIndex((item) => item.action === "hover");
+    next.splice(firstHover >= 0 ? firstHover : 0, 1);
+  }
+  return next;
+}
+function sameAttentionTarget(left, right) {
+  return left.kind === right.kind && left.id === right.id;
+}
+function createActivity(action, target, {
+  timestamp = Date.now(),
+  summary,
+  detail
+} = {}) {
+  return {
+    action,
+    target,
+    timestamp,
+    ...summary === void 0 ? {} : { summary },
+    ...detail === void 0 ? {} : { detail }
+  };
+}
+function deduplicateTargets(selections) {
+  const seen = /* @__PURE__ */ new Set();
+  return selections.filter((selection) => {
+    const key = `${selection.kind}\0${selection.id}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+
+// src/context-draft.ts
+import { useSyncExternalStore } from "react";
+var listeners = /* @__PURE__ */ new Set();
+var drafts = /* @__PURE__ */ new Map();
+var activeDraftScope = "default";
+var MAX_ATTACHMENTS = 6;
+var MAX_ATTACHMENT_TEXT_LENGTH = 192;
+var MAX_CONTEXT_DRAFT_BYTES = 8 * 1024;
+var ContextAttachmentSchema = standardSchema2(
+  (value) => {
+    const issues = validateAttachment(value);
+    return issues.length > 0 ? issues : value;
+  }
+);
+var ContextDraftPayloadSchema = standardSchema2(
+  (value) => {
+    const issues = validateDraftPayload(value);
+    return issues.length > 0 ? issues : value;
+  }
+);
+function attentionSelectionKey(selection) {
+  return `selection:${selection.kind}:${selection.id}`;
+}
+function attentionHistoryKey(event) {
+  return `history:${event.timestamp}:${event.action}:${event.target.kind}:${event.target.id}`;
+}
+function getContextDraftScope() {
+  return activeDraftScope;
+}
+function getAttentionExclusions() {
+  return getDraftState().exclusions;
+}
+function getTurnContextAttachments() {
+  return getDraftState().attachments;
+}
+function setContextDraftScope(scopeId) {
+  const normalized = scopeId.trim();
+  if (!normalized) throw new Error("Context draft scope must be non-empty");
+  if (activeDraftScope === normalized) return;
+  activeDraftScope = normalized;
+  getDraftState();
+  emitChange();
+}
+function addContextAttachment(attachment) {
+  const validated = validateAttachment(attachment);
+  if (validated.length > 0)
+    throw new Error(`Invalid context attachment: ${validated[0]?.message}`);
+  const normalized = normalizeAttachment(attachment, "expanded");
+  const state = getDraftState();
+  state.attachments = [
+    ...state.attachments.filter((item) => item.id !== normalized.id),
+    normalized
+  ].slice(-MAX_ATTACHMENTS);
+  emitChange();
+}
+function addTurnContextAttachment(selection, retention = "turn") {
+  addContextAttachment({
+    id: attentionSelectionKey(selection),
+    source: "application-selection",
+    inclusion: "user-added",
+    resource: { kind: selection.kind, id: selection.id },
+    label: truncateAttachmentText(selection.label ?? selection.id),
+    ...selection.detail ? {
+      summary: truncateAttachmentText(
+        Object.entries(selection.detail).sort(([left], [right]) => left.localeCompare(right)).map(([key, value]) => `${key}: ${value}`).join(" \xB7 ")
+      )
+    } : {},
+    retention
+  });
+}
+function removeTurnContextAttachment(id) {
+  const state = getDraftState();
+  const next = state.attachments.filter((item) => item.id !== id);
+  if (next.length === state.attachments.length) return;
+  state.attachments = next;
+  emitChange();
+}
+function moveTurnContextAttachment(id, direction) {
+  const state = getDraftState();
+  const index = state.attachments.findIndex((item) => item.id === id);
+  const target = index + direction;
+  if (index < 0 || target < 0 || target >= state.attachments.length) return;
+  const next = [...state.attachments];
+  [next[index], next[target]] = [next[target], next[index]];
+  state.attachments = next;
+  emitChange();
+}
+function setTurnContextAttachmentRetention(id, retention) {
+  let changed = false;
+  const state = getDraftState();
+  state.attachments = state.attachments.map((item) => {
+    if (item.id !== id || item.retention === retention) return item;
+    changed = true;
+    return { ...item, retention };
+  });
+  if (changed) emitChange();
+}
+function clearTurnContextAttachments() {
+  const state = getDraftState();
+  const next = state.attachments.filter((item) => item.retention === "session");
+  if (next.length === state.attachments.length) return;
+  state.attachments = next;
+  emitChange();
+}
+function clearContextDraft() {
+  const state = getDraftState();
+  if (state.exclusions.length === 0 && state.attachments.length === 0) return;
+  state.exclusions = [];
+  state.attachments = [];
+  emitChange();
+}
+function resetContextDraftForTests() {
+  drafts.clear();
+  activeDraftScope = "default";
+  emitChange();
+}
+function setAttentionItemExcluded(key, excluded) {
+  const state = getDraftState();
+  const next = new Set(state.exclusions);
+  if (excluded) next.add(key);
+  else next.delete(key);
+  state.exclusions = [...next].sort();
+  emitChange();
+}
+function clearAttentionExclusions() {
+  const state = getDraftState();
+  if (state.exclusions.length === 0) return;
+  state.exclusions = [];
+  emitChange();
+}
+function useAttentionExclusions() {
+  return useSyncExternalStore(
+    subscribeContextDraft,
+    getAttentionExclusions,
+    getAttentionExclusions
+  );
+}
+function useTurnContextAttachments() {
+  return useSyncExternalStore(
+    subscribeContextDraft,
+    getTurnContextAttachments,
+    getTurnContextAttachments
+  );
+}
+function serializeAttentionDraft(context, privacy, excludedKeys = getAttentionExclusions(), contextAttachments = getTurnContextAttachments()) {
+  const attention = context ? JSON.parse(
+    serializeAttention(
+      applyAttentionExclusions(context, excludedKeys),
+      privacy
+    )
+  ) : {};
+  const normalizedAttachments = contextAttachments.slice(0, MAX_ATTACHMENTS).map((attachment) => normalizeAttachment(attachment, privacy));
+  const serialized = fitContextPayload(attention, normalizedAttachments);
+  const parsed = JSON.parse(serialized);
+  const issues = validateDraftPayload(parsed);
+  if (issues.length > 0)
+    throw new Error(
+      `Invalid context draft serialization: ${issues[0]?.message}`
+    );
+  return serialized;
+}
+function createAttentionContextPreview(context, privacy, excludedKeys = getAttentionExclusions(), contextAttachments = getTurnContextAttachments()) {
+  const serialized = serializeAttentionDraft(
+    context,
+    privacy,
+    excludedKeys,
+    contextAttachments
+  );
+  const normalized = JSON.parse(serialized);
+  const selections = normalized.selections?.length ? normalized.selections : normalized.selection ? [normalized.selection] : [];
+  const history = normalized.history ?? [];
+  const normalizedAttachments = normalized.attachments ?? [];
+  const truncatedAttachmentCount = Math.max(
+    0,
+    contextAttachments.length - normalizedAttachments.length
+  );
+  const byteLength3 = new TextEncoder().encode(serialized).byteLength;
+  const parts = [
+    `${selections.length} selection${selections.length === 1 ? "" : "s"}`,
+    `${normalizedAttachments.length} attachment${normalizedAttachments.length === 1 ? "" : "s"}`,
+    `${history.length} recent action${history.length === 1 ? "" : "s"}`
+  ];
+  return {
+    attachmentCount: normalizedAttachments.length,
+    attachments: normalizedAttachments,
+    byteLength: byteLength3,
+    estimatedTokens: Math.ceil(byteLength3 / 4),
+    formatted: JSON.stringify(normalized, null, 2),
+    history,
+    selectionCount: selections.length,
+    selections,
+    serialized,
+    summary: parts.join(" \xB7 "),
+    truncatedAttachmentCount
+  };
+}
+function applyAttentionExclusions(context, excludedKeys) {
+  if (excludedKeys.length === 0) return context;
+  const excluded = new Set(excludedKeys);
+  const selectionCandidates = deduplicateSelections([
+    ...context.selection ? [context.selection] : [],
+    ...context.selections ?? []
+  ]);
+  const selections = selectionCandidates.filter(
+    (selection) => !excluded.has(attentionSelectionKey(selection))
+  );
+  const excludedTargets = new Set(
+    selectionCandidates.filter((selection) => excluded.has(attentionSelectionKey(selection))).map((selection) => `${selection.kind}\0${selection.id}`)
+  );
+  const history = (context.history ?? []).filter(
+    (event) => !excluded.has(attentionHistoryKey(event)) && !excludedTargets.has(`${event.target.kind}\0${event.target.id}`)
+  );
+  const hover = context.hover && !excluded.has(attentionSelectionKey(context.hover)) && !excludedTargets.has(`${context.hover.kind}\0${context.hover.id}`) ? context.hover : void 0;
+  return {
+    ...context,
+    selection: selections[0],
+    selections: selections.length > 0 ? selections : void 0,
+    history: history.length > 0 ? history : void 0,
+    hover
+  };
+}
+function deduplicateSelections(selections) {
+  const seen = /* @__PURE__ */ new Set();
+  return selections.filter((selection) => {
+    const key = `${selection.kind}\0${selection.id}`;
+    if (seen.has(key)) return false;
+    seen.add(key);
+    return true;
+  });
+}
+function subscribeContextDraft(listener) {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+function emitChange() {
+  listeners.forEach((listener) => listener());
+}
+function getDraftState() {
+  let state = drafts.get(activeDraftScope);
+  if (!state) {
+    state = { attachments: [], exclusions: [] };
+    drafts.set(activeDraftScope, state);
+  }
+  return state;
+}
+function normalizeAttachment(attachment, privacy) {
+  return {
+    id: truncateAttachmentText(attachment.id),
+    source: attachment.source,
+    inclusion: attachment.inclusion,
+    resource: {
+      kind: truncateAttachmentText(attachment.resource.kind),
+      id: truncateAttachmentText(attachment.resource.id)
+    },
+    label: privacy === "minimal" ? truncateAttachmentText(attachment.resource.id) : truncateAttachmentText(attachment.label),
+    ...privacy === "minimal" || attachment.summary === void 0 ? {} : { summary: truncateAttachmentText(attachment.summary) },
+    retention: attachment.retention
+  };
+}
+function fitContextPayload(attention, contextAttachments) {
+  const included = contextAttachments.map((attachment) => ({ ...attachment }));
+  let serialized = serializeContextPayload(attention, included);
+  if (byteLength2(serialized) <= MAX_CONTEXT_DRAFT_BYTES) return serialized;
+  for (let index = included.length - 1; index >= 0; index -= 1) {
+    if (included[index]?.summary === void 0) continue;
+    delete included[index].summary;
+    serialized = serializeContextPayload(attention, included);
+    if (byteLength2(serialized) <= MAX_CONTEXT_DRAFT_BYTES) return serialized;
+  }
+  while (included.length > 0) {
+    included.pop();
+    serialized = serializeContextPayload(attention, included);
+    if (byteLength2(serialized) <= MAX_CONTEXT_DRAFT_BYTES) return serialized;
+  }
+  return serialized;
+}
+function serializeContextPayload(attention, included) {
+  return JSON.stringify({
+    ...attention,
+    ...included.length > 0 ? { attachments: included } : {}
+  });
+}
+function validateDraftPayload(value) {
+  if (!isRecord2(value)) return [issue2("Expected a context draft payload")];
+  const { attachments, ...attention } = value;
+  const issues = [];
+  if (Object.keys(attention).length > 0)
+    issues.push(...validateAttentionContext(attention));
+  if (attachments !== void 0) {
+    if (!Array.isArray(attachments))
+      issues.push(issue2("Expected attachments", "attachments"));
+    else
+      attachments.forEach(
+        (attachment, index) => issues.push(...validateAttachment(attachment, ["attachments", index]))
+      );
+  }
+  return issues;
+}
+function validateAttachment(value, path = []) {
+  if (!isRecord2(value)) return [issue2("Expected an attachment", ...path)];
+  const issues = [];
+  if (!hasOnlyKeys2(value, [
+    "id",
+    "source",
+    "inclusion",
+    "resource",
+    "label",
+    "summary",
+    "retention"
+  ]))
+    issues.push(issue2("Unexpected attachment field", ...path));
+  for (const key of ["id", "label"])
+    if (typeof value[key] !== "string")
+      issues.push(issue2("Expected a string", ...path, key));
+  if (value.summary !== void 0 && typeof value.summary !== "string")
+    issues.push(issue2("Expected a string", ...path, "summary"));
+  if (value.source !== "application-selection" && value.source !== "semantic-fork" && value.source !== "agent-requested")
+    issues.push(issue2("Expected a supported source", ...path, "source"));
+  if (value.inclusion !== "user-added" && value.inclusion !== "automatic" && value.inclusion !== "agent-requested")
+    issues.push(issue2("Expected a supported inclusion", ...path, "inclusion"));
+  if (value.retention !== "turn" && value.retention !== "session")
+    issues.push(
+      issue2("Expected turn or session retention", ...path, "retention")
+    );
+  if (!isRecord2(value.resource))
+    issues.push(issue2("Expected a resource", ...path, "resource"));
+  else {
+    if (!hasOnlyKeys2(value.resource, ["kind", "id"]))
+      issues.push(issue2("Unexpected resource field", ...path, "resource"));
+    for (const key of ["kind", "id"])
+      if (typeof value.resource[key] !== "string")
+        issues.push(issue2("Expected a string", ...path, "resource", key));
+  }
+  return issues;
+}
+function standardSchema2(validate) {
+  return {
+    "~standard": {
+      version: 1,
+      vendor: "sigil-agent",
+      validate(value) {
+        const result = validate(value);
+        return Array.isArray(result) ? { issues: result } : { value: result };
+      }
+    }
+  };
+}
+function issue2(message, ...path) {
+  return { message, path };
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOnlyKeys2(value, allowed) {
+  const keys = new Set(allowed);
+  return Object.keys(value).every((key) => keys.has(key));
+}
+function truncateAttachmentText(value) {
+  return value.length <= MAX_ATTACHMENT_TEXT_LENGTH ? value : `${value.slice(0, MAX_ATTACHMENT_TEXT_LENGTH - 1)}\u2026`;
+}
+function byteLength2(value) {
+  return new TextEncoder().encode(value).byteLength;
+}
+
+// src/context-privacy.ts
+import { useSyncExternalStore as useSyncExternalStore2 } from "react";
+var ATTENTION_PRIVACY_STORAGE_KEY = "sigil-agent:attention-privacy";
+var listeners2 = /* @__PURE__ */ new Set();
+var cachedLevel;
+var listeningForStorage = false;
+var AttentionPrivacyLevelSchema = {
+  "~standard": {
+    version: 1,
+    vendor: "sigil-agent",
+    validate(value) {
+      return isAttentionPrivacyLevel(value) ? { value } : { issues: [{ message: "Expected minimal, focused, or expanded" }] };
+    }
+  }
+};
+function getAttentionPrivacyLevel() {
+  if (typeof window === "undefined") return "focused";
+  if (cachedLevel === void 0)
+    cachedLevel = parseAttentionPrivacyLevel(
+      window.localStorage.getItem(ATTENTION_PRIVACY_STORAGE_KEY)
+    );
+  return cachedLevel;
+}
+function setAttentionPrivacyLevel(level) {
+  cachedLevel = level;
+  if (typeof window !== "undefined")
+    window.localStorage.setItem(ATTENTION_PRIVACY_STORAGE_KEY, level);
+  emitChange2();
+}
+function useAttentionPrivacyLevel() {
+  return useSyncExternalStore2(
+    subscribeAttentionPrivacyLevel,
+    getAttentionPrivacyLevel,
+    () => "focused"
+  );
+}
+function subscribeAttentionPrivacyLevel(listener) {
+  listeners2.add(listener);
+  if (typeof window !== "undefined" && !listeningForStorage) {
+    window.addEventListener("storage", handleStorage);
+    listeningForStorage = true;
+  }
+  return () => {
+    listeners2.delete(listener);
+    if (typeof window !== "undefined" && listeningForStorage && listeners2.size === 0) {
+      window.removeEventListener("storage", handleStorage);
+      listeningForStorage = false;
+    }
+  };
+}
+function parseAttentionPrivacyLevel(value) {
+  return value === "minimal" || value === "expanded" ? value : "focused";
+}
+function resetAttentionPrivacyForTests() {
+  cachedLevel = void 0;
+  listeners2.clear();
+  if (typeof window !== "undefined" && listeningForStorage)
+    window.removeEventListener("storage", handleStorage);
+  listeningForStorage = false;
+}
+function handleStorage(event) {
+  if (event.key !== ATTENTION_PRIVACY_STORAGE_KEY) return;
+  cachedLevel = parseAttentionPrivacyLevel(event.newValue);
+  emitChange2();
+}
+function isAttentionPrivacyLevel(value) {
+  return value === "minimal" || value === "focused" || value === "expanded";
+}
+function emitChange2() {
+  listeners2.forEach((listener) => listener());
+}
+
+// src/session.tsx
+import { createContext as createContext2, useContext as useContext2 } from "react";
+import { jsx } from "react/jsx-runtime";
+var AgentRuntimeSessionContext = createContext2(
+  null
+);
+function AgentRuntimeSessionProvider({
+  children,
+  session
+}) {
+  return /* @__PURE__ */ jsx(AgentRuntimeSessionContext.Provider, { value: session, children });
+}
+function useAgentRuntimeSession() {
+  const session = useContext2(AgentRuntimeSessionContext);
+  if (!session) {
+    throw new Error(
+      "useAgentRuntimeSession must be used within <AgentRuntimeSessionProvider>."
+    );
+  }
+  return session;
+}
+
+// src/thread-controls.tsx
+import {
+  createContext as createContext3,
+  createElement as createElement2,
+  useContext as useContext3
+} from "react";
+var AgentThreadControlsContext = createContext3(
+  null
+);
+function AgentThreadControlsProvider({
+  children,
+  value
+}) {
+  return createElement2(
+    AgentThreadControlsContext.Provider,
+    { value },
+    children
+  );
+}
+function useAgentThreadControls() {
+  return useContext3(AgentThreadControlsContext);
+}
+export {
+  ATTENTION_ACTIVITY_ACTIONS,
+  ATTENTION_PRIVACY_STORAGE_KEY,
+  AgentRuntimeSessionProvider,
+  AgentThreadControlsProvider,
+  AttentionContextSchema,
+  AttentionPrivacyLevelSchema,
+  AttentionProvider,
+  ContextAttachmentSchema,
+  ContextDraftPayloadSchema,
+  addContextAttachment,
+  addTurnContextAttachment,
+  appendBoundedActivity,
+  applyAttentionExclusions,
+  attentionHistoryKey,
+  attentionSelectionKey,
+  clearAttentionExclusions,
+  clearContextDraft,
+  clearTurnContextAttachments,
+  createAttentionContextPreview,
+  createAttentionTelemetryState,
+  formatAttentionLabel,
+  getAttentionExclusions,
+  getAttentionPrivacyLevel,
+  getContextDraftScope,
+  getTurnContextAttachments,
+  moveTurnContextAttachment,
+  parseAttentionPrivacyLevel,
+  reduceAttentionTelemetry,
+  removeTurnContextAttachment,
+  resetAttentionPrivacyForTests,
+  resetContextDraftForTests,
+  sameAttentionTarget,
+  serializeAttention,
+  serializeAttentionDraft,
+  setAttentionItemExcluded,
+  setAttentionPrivacyLevel,
+  setContextDraftScope,
+  setTurnContextAttachmentRetention,
+  subscribeAttentionPrivacyLevel,
+  useAgentRuntimeSession,
+  useAgentThreadControls,
+  useAttention,
+  useAttentionExclusions,
+  useAttentionPrivacyLevel,
+  useAttentionTelemetry,
+  useTurnContextAttachments,
+  validateAttentionContext
+};
+//# sourceMappingURL=index.js.map