@capekai/core 1.0.0

package/src/goals/loop.ts

@@ -0,0 +1,167 @@
+import type { GoalState, Session } from '@capekai/types';
+import { emitSessionUpdated } from '../runtime/host-dependencies';
+import { getSession, updateSession } from '../storage/runtime';
+import type { BroadcastFn, BroadcastSessionFn } from '../runtime/host';
+import {
+  buildContinuationMessage,
+  evaluateGoal,
+  evaluateGoalWithDeps,
+  type EvaluateGoalOptions,
+} from './evaluator';
+
+/**
+ * Goal domain: the persistent goal loop. Moved byte-for-byte from
+ * `core/goal-loop.ts`; the unscoped export keeps the pre-C5 module path
+ * (module storage, module broadcast, module evaluator), and
+ * `runGoalLoopWithDeps` runs against the injected session access, goal
+ * state updates, evaluator, and broadcast defaults captured by the goal
+ * domain plugin. Goal state stays on `session.metadata.goal` with the exact
+ * lifecycle transitions: active, met, failed, cancelled.
+ */
+
+export type RunTurnFn = (content: string) => Promise<{ streamCompleted: boolean; interrupted: boolean }>;
+
+export interface GoalLoopOptions {
+  sessionId: string;
+  condition: string;
+  initialPrompt?: string;
+  maxTurns?: number;
+  abortSignal?: AbortSignal;
+  broadcast?: BroadcastFn;
+  broadcastSessionCreated?: BroadcastSessionFn;
+  broadcastSessionUpdated?: BroadcastSessionFn;
+  runTurn: RunTurnFn;
+  evaluate?: typeof evaluateGoal;
+}
+
+export interface GoalLoopDeps {
+  getSession(id: string): Session | null | Promise<Session | null>;
+  updateSession(id: string, updates: Partial<Session>): Session | null | Promise<Session | null>;
+  evaluate(options: EvaluateGoalOptions): ReturnType<typeof evaluateGoalWithDeps>;
+  broadcastSessionUpdatedDefault(session: Session): void;
+}
+
+async function updateGoalStateWithDeps(
+  deps: GoalLoopDeps,
+  sessionId: string,
+  updates: Partial<GoalState>,
+  broadcastSessionUpdatedFn?: BroadcastSessionFn,
+): Promise<void> {
+  const session = await deps.getSession(sessionId);
+  if (!session) return;
+  const metadata = session.metadata ?? {};
+  const existingGoal = metadata.goal as GoalState | undefined;
+  if (!existingGoal) return;
+  const updated = await deps.updateSession(sessionId, { metadata: { ...metadata, goal: { ...existingGoal, ...updates } } });
+  if (updated) (broadcastSessionUpdatedFn ?? deps.broadcastSessionUpdatedDefault)(updated);
+}
+
+/** Unscoped goal loop: the pre-C5 module accessors. */
+export async function runGoalLoop(options: GoalLoopOptions): Promise<void> {
+  return runGoalLoopWithDeps(options, {
+    getSession,
+    updateSession,
+    evaluate: (evaluateOptions) => evaluateGoal(evaluateOptions),
+    broadcastSessionUpdatedDefault: emitSessionUpdated,
+  });
+}
+
+/** Composed goal loop over the dependencies captured by the goal domain
+ * plugin. */
+export async function runGoalLoopWithDeps(
+  options: GoalLoopOptions,
+  deps: GoalLoopDeps,
+): Promise<void> {
+  const maxTurns = options.maxTurns ?? 5;
+  const {
+    sessionId,
+    condition,
+    initialPrompt,
+    abortSignal,
+    broadcast,
+    broadcastSessionCreated,
+    broadcastSessionUpdated: broadcastSessUpdated,
+    runTurn,
+    evaluate = (evaluateOptions: EvaluateGoalOptions) => deps.evaluate(evaluateOptions),
+  } = options;
+
+  console.log('[goal:loop] Starting goal loop', {
+    sessionId,
+    conditionPreview: condition.slice(0, 80),
+    maxTurns,
+    hasInitialPrompt: !!initialPrompt,
+  });
+
+  const session = await deps.getSession(sessionId);
+  if (!session) {
+    console.error('[goal:loop] Session not found', { sessionId });
+    return;
+  }
+  const goalState: GoalState = {
+    condition,
+    maxTurns,
+    currentTurn: 0,
+    status: 'active',
+    startedAt: Date.now(),
+  };
+  const initialized = await deps.updateSession(sessionId, { metadata: { ...(session.metadata ?? {}), goal: goalState } });
+  if (initialized) (broadcastSessUpdated ?? deps.broadcastSessionUpdatedDefault)(initialized);
+
+  let nextTurnContent = initialPrompt || condition;
+  for (let turn = 1; turn <= maxTurns; turn++) {
+    if (abortSignal?.aborted) {
+      console.log('[goal:loop] Aborted before turn', { turn });
+      await updateGoalStateWithDeps(deps, sessionId, { status: 'cancelled', completedAt: Date.now() }, broadcastSessUpdated);
+      return;
+    }
+    await updateGoalStateWithDeps(deps, sessionId, { currentTurn: turn }, broadcastSessUpdated);
+    console.log('[goal:loop] Starting turn', { turn, maxTurns, contentPreview: nextTurnContent.slice(0, 80) });
+
+    const result = await runTurn(nextTurnContent);
+    console.log('[goal:loop] Turn completed', { turn, streamCompleted: result.streamCompleted, interrupted: result.interrupted });
+
+    if (result.interrupted) {
+      console.log('[goal:loop] Turn was interrupted, stopping goal loop', { turn });
+      await updateGoalStateWithDeps(deps, sessionId, { status: 'cancelled', completedAt: Date.now() }, broadcastSessUpdated);
+      return;
+    }
+
+    if (!result.streamCompleted) {
+      console.log('[goal:loop] Turn stream did not complete, stopping goal loop', { turn });
+      await updateGoalStateWithDeps(deps, sessionId, { status: 'failed', completedAt: Date.now() }, broadcastSessUpdated);
+      return;
+    }
+
+    if (abortSignal?.aborted) {
+      console.log('[goal:loop] Aborted after turn', { turn });
+      await updateGoalStateWithDeps(deps, sessionId, { status: 'cancelled', completedAt: Date.now() }, broadcastSessUpdated);
+      return;
+    }
+
+    let evaluation;
+    try {
+      evaluation = await evaluate({
+        sessionId,
+        condition,
+        turn,
+        maxTurns,
+        abortSignal,
+        broadcast,
+        broadcastSessionCreated,
+        broadcastSessionUpdated: broadcastSessUpdated,
+      });
+    } catch (err) {
+      console.error('[goal:loop] Evaluator failed', { turn, error: err instanceof Error ? err.message : String(err) });
+      evaluation = { goalMet: false, reason: 'Evaluator call failed — continuing work' };
+    }
+    if (evaluation.goalMet) {
+      console.log('[goal:loop] GOAL MET!', { turn, reason: evaluation.reason });
+      await updateGoalStateWithDeps(deps, sessionId, { status: 'met', completedAt: Date.now() }, broadcastSessUpdated);
+      return;
+    }
+    nextTurnContent = buildContinuationMessage(condition, evaluation.reason, evaluation.remainingWork);
+    console.log('[goal:loop] Prepared continuation for next turn', { turn, continuationPreview: nextTurnContent.slice(0, 80) });
+  }
+  console.log('[goal:loop] Max turns reached without meeting goal', { maxTurns });
+  await updateGoalStateWithDeps(deps, sessionId, { status: 'failed', completedAt: Date.now() }, broadcastSessUpdated);
+}

package/src/goals/service.ts

@@ -0,0 +1,39 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { evaluateGoal, type EvaluateGoalOptions } from './evaluator';
+import { runGoalLoop, type GoalLoopOptions } from './loop';
+
+/**
+ * Goal domain service access. The composed agent scope seeds the plugin
+ * service here through `enterAgentScope` (when the goal domain plugin is
+ * installed); consumers resolve the active service through `getGoalDomain()`.
+ * Unscoped consumers keep the pre-adoption module path (module storage,
+ * module broadcast, module evaluator) as the fallback, exactly like the C6
+ * policy accessors.
+ */
+
+export interface GoalDomainService {
+  evaluateGoal(options: EvaluateGoalOptions): ReturnType<typeof evaluateGoal>;
+  runGoalLoop(options: GoalLoopOptions): Promise<void>;
+}
+
+const scopedService = new AsyncLocalStorage<GoalDomainService>();
+
+function unscopedGoalDomain(): GoalDomainService {
+  return {
+    evaluateGoal: (options) => evaluateGoal(options),
+    runGoalLoop: (options) => runGoalLoop(options),
+  };
+}
+
+/** Resolves the scoped goal domain service, or the unscoped module-path
+ * fallback outside a composed agent scope. */
+export function getGoalDomain(): GoalDomainService {
+  return scopedService.getStore() ?? unscopedGoalDomain();
+}
+
+/** Seeds a service for the callback duration. `enterAgentScope` seeds the
+ * composed agent scope's service here when the goal domain plugin is
+ * installed. */
+export function withGoalDomain<T>(service: GoalDomainService, callback: () => T): T {
+  return scopedService.run(service, callback);
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+export const capekPackagePhase = 9 as const;
+
+export type { ToolOutputArtifactPage } from './storage/contracts';
+export type {
+  RuntimeAudience,
+  RuntimeDelivery,
+  RuntimeEvent,
+  RuntimeEventContext,
+  RuntimeEventSink,
+} from './runtime/events';

package/src/internal/ask-authority.ts

@@ -0,0 +1,29 @@
+/**
+ * Public ask authority entrypoint (`@capekai/core/ask-authority`).
+ *
+ * Exposes exactly the pending-ask permission identities the Jean2 server
+ * consumes at the wire boundary: response resolution, pending-ask session
+ * and authority lookup, and the fixed ask timeout. Every symbol resolves to
+ * the owning module's identity, identical to the compatibility barrel.
+ * S8a/S8d: this is the single authority surface for pending-ask
+ * resolution; the server consumes it only through the ask-authority
+ * adapter.
+ */
+
+export {
+  ASK_TIMEOUT,
+  createAskApi,
+  getAuthorityForPendingAsk,
+  getSessionIdForPendingAsk,
+  hasPendingAsk,
+  rejectPendingAsksByToolCallId,
+  resolveAsk,
+} from '../permission/ask-user-api';
+export {
+  getPendingRequestsByRootSession,
+  hasPendingWaiter,
+  rejectPermission,
+  rejectPermissionsBySession,
+  requestPermission,
+  resolvePermission,
+} from '../permission/permission-request-manager';

package/src/internal/composition.ts

@@ -0,0 +1,44 @@
+/** Public package-owned generic composition entrypoint. */
+
+export {
+  createAgentScope,
+  createComposition,
+  createProcessScope,
+  enterAgentScope,
+  facadeProcessPlugins,
+  type Composition,
+} from '../plugins/compose';
+export type {
+  AgentScopeHandle,
+  CapekPlugin,
+  ProcessScopeHandle,
+} from '../plugins/compose';
+export {
+  capekAgentDriverKey,
+  capekContextAssemblerKey,
+  capekContextSourcesKey,
+  capekInstalledToolRegistryKey,
+  capekProviderOverridesKey,
+  capekProviderRegistryKey,
+  capekRuntimeConfigurationKey,
+  capekRuntimeHostKey,
+  capekSandboxControllerKey,
+  capekSchedulerHostKey,
+  capekSessionSearchHostKey,
+  capekStorageKey,
+  capekToolResolverKey,
+  capekWorkspaceToolDiscoveryKey,
+} from '../plugins/service-keys';
+export {
+  C2_PROCESS_KEYS,
+  C2_REQUIRED_AGENT_KEYS,
+  C2_SERVICE_KEYS,
+} from '../plugins/service-keys';
+export type {
+  InstalledToolRegistryContract,
+  ProviderRegistryContract,
+} from '../plugins/service-keys';
+export type {
+  ContextAssembler,
+  ContextAssemblyData,
+} from '../plugins/service-keys';

package/src/internal/configuration.ts

@@ -0,0 +1,22 @@
+/**
+ * Public configuration entrypoint (`@capekai/core/configuration`).
+ *
+ * Exposes exactly the runtime-configuration identities the Jean2 server
+ * consumes through its runtime-configuration adapter: the configuration
+ * accessors and the API-key resolution. Every symbol resolves to the owning
+ * module's identity, identical to the compatibility barrel. S8a.
+ */
+
+export {
+  configureRuntimeConfiguration,
+  getApiKeyForProvider,
+  getRuntimeConfiguration,
+  withRuntimeConfiguration,
+} from '../configuration/runtime';
+export type { RuntimeConfiguration } from '../configuration/contracts';
+export { createDefaultRuntimeConfiguration } from '../configuration/defaults';
+export {
+  createSingleModelConfiguration,
+  resolveModelSpecifier,
+  type ModelSpecifierSelection,
+} from '../configuration/single-model';

package/src/internal/execution.ts

@@ -0,0 +1,108 @@
+/**
+ * Public execution entrypoint (`@capekai/core/execution`).
+ *
+ * Exposes exactly the agent execution identities the Jean2 server consumes
+ * through its execution port: chat, edit, title regeneration, compaction,
+ * fork, revert, and the interrupt manager. Every symbol resolves to the
+ * owning module's identity, identical to the compatibility barrel. S8a.
+ */
+
+export {
+  handleChat,
+  handleSessionEditMessage,
+  regenerateSessionTitle,
+  type RuntimeRequestContext,
+} from '../core/chat-handler';
+export { interruptManager } from '../core/interrupt';
+export { forkSession } from '../core/fork';
+export { revertToStep } from '../core/revert';
+export {
+  executeCompaction,
+  isCompactionActive,
+} from '../compaction/executor';
+export {
+  getDefaultCompactionPolicy,
+  resolveCompactionPolicy,
+} from '../compaction/policy';
+export {
+  buildConversationText,
+  createCompactionTrigger,
+  estimateToolOutputSize,
+  formatOutput,
+  persistCompactionFailure,
+  processCompactionTask,
+} from '../compaction/task';
+export type { GenerateSummaryFn } from '../compaction/contracts';
+export {
+  reconcileAllSessionsCompaction as reconcileAllSessionsCompactionWithDeps,
+  reconcileSessionCompaction as reconcileSessionCompactionWithDeps,
+  type CompactionRecoveryDeps,
+} from '../compaction/recovery';
+export type { RuntimeEventSink } from '../runtime/events';
+
+// S8f test-surface additions: the execution-domain identities the server
+// tests consume (agent stream loop, retry policy, goal evaluation, workflow
+// orchestration, subagent policy, tool building, message/part/model utils,
+// error classification, structured output, stream configuration, tool
+// capabilities, and the fixed legacy system-message builder). Each symbol
+// keeps its owning module's identity, identical to the compatibility barrel.
+export type { ChatOptions } from '../core/agent';
+export {
+  createRetryCircuitState,
+  withRetryCircuitState,
+} from '../retry/policy';
+export {
+  streamChatWithRetry,
+  type StreamChatEvent,
+  type StreamChatFn,
+} from '../retry/stream-chat';
+export { buildContinuationMessage } from '../goals/evaluator';
+export { runOrchestratorSession } from '../workflow/orchestrator-session';
+export {
+  collectSubagentAncestry,
+  evaluateSubagentTarget,
+  getSubagentResumeError,
+  isSubagentSpawningDisabled,
+  isValidSubagentPreconfig,
+  isValidSubagentTargetPreconfig,
+} from '../subagent/policy';
+export {
+  buildAiSdkTools,
+  type BuildToolsOptions,
+} from '../core/build-tools';
+export { convertToAiSdkMessages } from '../core/message-utils';
+export {
+  createStepPart,
+  isFilePart,
+  isImagePart,
+  isTextPart,
+  isToolPart,
+  parseToolInput,
+} from '../core/part-utils';
+export { getModelWithMetadata } from '../core/model-utils';
+export { createErrorEvent } from '../core/error-handling';
+export {
+  classifyApiError,
+  withRetry,
+  ApiErrorType,
+  type ClassifiedError,
+} from '../utils/errors';
+export {
+  buildSchemaPromptInstruction,
+  extractJsonFromText,
+} from '../core/structured-output';
+export {
+  resolveToolExecutionScopes,
+  isToolAllowedInContext,
+} from '../core/tool-capabilities';
+export { buildStreamConfig } from '../core/stream/stream-config';
+export {
+  createStreamHandlers,
+  type StreamHandlerContext,
+} from '../core/stream-handlers';
+export {
+  createStepCallbacks,
+  type StepCallbacksContext,
+} from '../core/step-handlers';
+export { buildSystemMessage } from '../plugins/legacy-system-message';
+export { createWorkspaceCapability } from '../workspace/policy';

package/src/internal/hosts.ts

@@ -0,0 +1,64 @@
+/**
+ * Public host-composition entrypoint (`@capekai/core/hosts`).
+ *
+ * Exposes exactly the process-global host configuration the Jean2 server
+ * bootstrap installs: runtime host bindings, session-search and scheduler
+ * hosts, and context sources. Every symbol resolves to the owning module's
+ * identity, identical to the compatibility barrel. S8a.
+ */
+
+export {
+  configureRuntimeHost,
+  getRuntimeHost,
+  withRuntimeHost,
+  type AskBroadcastFn,
+  type BroadcastFn,
+  type BroadcastSessionFn,
+  type CreateGrantParams,
+  type DeliveryHost,
+  type InteractionHost,
+  type MatchGrantParams,
+  type PendingAskRecord,
+  type PermissionRequestStatus,
+  type RuntimeHost,
+  type SandboxBindings,
+  type TitleHost,
+  type WorkspaceCapabilityBindings,
+} from '../runtime/host';
+export { createStandaloneHost } from '../runtime/standalone-host';
+export { installSchedulerToolFallback } from '../plugins/scheduler-domain';
+export { installSessionSearchToolFallback } from '../plugins/session-search-domain';
+export { installTaskToolFallback } from '../plugins/subagent-domain';
+export { installWorkflowToolFallback } from '../plugins/workflow-domain';
+export { installMemoryToolFallback } from '../plugins/memory-domain';
+export { installSkillsToolFallback } from '../plugins/skills-domain';
+export { setDefaultContextAssembler } from '../context/assembler';
+export { fixedBuilderContextAssembler } from '../plugins/legacy-system-message';
+export { configureSessionSearchHost, getSessionSearchHost, type SessionSearchHost } from '../session-search/host';
+export { configureSchedulerHost, getSchedulerHost, type SchedulerHost } from '../scheduler/host';
+export { executeSchedulerTool } from '../scheduler/scheduler-tool';
+export { executeSessionSearchTool } from '../session-search/session-search-tool';
+export { executeSkillManageTool, buildSkillManageToolDescription } from '../skills/skill-manage-tool';
+export { executeMemoryTool } from '../memory/memory-tool';
+export {
+  addEntry,
+  entriesToContent,
+  formatEntriesForDisplay,
+  formatMemorySection,
+  listEntries,
+  loadMemoryFile,
+  loadMemoryInstructions,
+  MEMORY_CHAR_LIMIT,
+  parseEntries,
+  removeEntry,
+  replaceEntry,
+  USER_CHAR_LIMIT,
+} from '../memory/registry';
+export {
+  configureAgentSource,
+  configureInstructionSource,
+  configurePreconfigSource,
+  type AgentSource,
+  type InstructionSource,
+  type PreconfigSource,
+} from '../context/sources';

package/src/internal/plugins.ts

@@ -0,0 +1,71 @@
+/** Public composition plugin inventory for embedding hosts. */
+
+export {
+  contextSourcesValuePlugin,
+  installedToolRegistryValuePlugin,
+  providerOverridesValuePlugin,
+  providerRegistryValuePlugin,
+  runtimeConfigurationValuePlugin,
+  runtimeHostValuePlugin,
+  sandboxControllerValuePlugin,
+  schedulerHostValuePlugin,
+  sessionSearchHostValuePlugin,
+  storageValuePlugin,
+  toolResolverValuePlugin,
+  workspaceToolDiscoveryValuePlugin,
+} from '../plugins/value-plugins';
+export { retryPolicyPlugin } from '../plugins/retry-policy';
+export { compactionPolicyPlugin } from '../plugins/compaction-policy';
+export { permissionPolicyPlugin } from '../plugins/permission-policy';
+export { workspacePolicyPlugin } from '../plugins/workspace-policy';
+export { toolOutputPolicyPlugin } from '../plugins/tool-output-policy';
+export { defaultAgentDriverPlugin } from '../plugins/default-agent-driver';
+export { createContextSectionsPlugin } from '../plugins/context-sections';
+export { orchestratorSessionProviderPlugin } from '../plugins/orchestrator-session';
+export {
+  CURRENT_SESSION_SEARCH_DOMAIN_PLUGIN_ID,
+  sessionSearchDomainPlugin,
+} from '../plugins/session-search-domain';
+export {
+  CURRENT_SCHEDULER_DOMAIN_PLUGIN_ID,
+  schedulerDomainPlugin,
+} from '../plugins/scheduler-domain';
+export {
+  CURRENT_SUBAGENT_DOMAIN_PLUGIN_ID,
+  subagentDomainPlugin,
+} from '../plugins/subagent-domain';
+export {
+  CURRENT_WORKFLOW_DOMAIN_PLUGIN_ID,
+  workflowDomainPlugin,
+} from '../plugins/workflow-domain';
+export {
+  CURRENT_GOAL_DOMAIN_PLUGIN_ID,
+  goalDomainPlugin,
+} from '../plugins/goal-domain';
+export {
+  CURRENT_MEMORY_DOMAIN_PLUGIN_ID,
+  memoryDomainPlugin,
+} from '../plugins/memory-domain';
+export {
+  CURRENT_SKILLS_DOMAIN_PLUGIN_ID,
+  skillsDomainPlugin,
+} from '../plugins/skills-domain';
+export {
+  FACADE_AGENT_PLUGIN_IDS,
+  FACADE_PROCESS_PLUGIN_IDS,
+  createFacadeAgentPlugins,
+  facadeProcessPlugins,
+  type FacadeScopeValues,
+} from '../plugins/facade-plugins';
+export { loadedToolsPlugin } from '../plugins/loaded-tools';
+export { createContributedToolResolver } from '../plugins/tool-catalog';
+export {
+  getContextSources,
+} from '../context/sources';
+export { getRuntimeConfiguration } from '../configuration/runtime';
+export { getRuntimeHost } from '../runtime/host';
+export { getWorkspaceToolDiscovery } from '../tools/tool-source';
+export { getSandboxController } from '../sandbox/controller';
+export { getStorage } from '../storage/runtime';
+export { getSessionSearchHost } from '../session-search/host';
+export { getSchedulerHost } from '../scheduler/host';

package/src/internal/providers.ts

@@ -0,0 +1,32 @@
+/**
+ * Public providers entrypoint (`@capekai/core/providers`).
+ *
+ * Exposes exactly the provider-registry identities the Jean2 server
+ * consumes: registration, lookup, status, connect/disconnect, model
+ * factories, and the AI SDK model adapters (title generation, OpenAI
+ * Responses construction, capability tool conversion). Every symbol
+ * resolves to the owning module's identity, identical to the
+ * compatibility barrel. S8a.
+ */
+
+export {
+  connectProvider,
+  createModelForProvider,
+  disconnectProvider,
+  getConnectableProviders,
+  getProvider,
+  getProviderStatus,
+  registerProvider,
+  withProviderOverrides,
+} from '../providers/registry';
+export type { ConnectableProvider } from '../providers/types';
+export type { TokenResponse } from '../providers/types';
+export type { ModelFactoryOptions } from '../providers/types';
+export {
+  createCapabilityTool,
+  createOpenAiResponsesModel,
+  runTextModel,
+  type CapabilityTool,
+} from '../adapters/ai-sdk';
+export { findProviderFromModel } from '../core/provider-utils';
+export { executeChildSession } from '../subagent/child-session';

package/src/internal/sandbox.ts

@@ -0,0 +1,19 @@
+/**
+ * Public sandbox entrypoint (`@capekai/core/sandbox`).
+ *
+ * Exposes exactly the sandbox identities the Jean2 server consumes: the
+ * process controller, provider registration, and the wire message types
+ * for auto-responder rules and responses. Every symbol resolves to the
+ * owning module's identity, identical to the compatibility barrel. S8a.
+ */
+
+export { SandboxController, sandboxController } from '../sandbox/controller';
+export { SandboxProvider } from '../sandbox/provider';
+export { SandboxLanguageModel } from '../sandbox/model';
+export type {
+  AutoResponderRule,
+  LlmCallContext,
+  SandboxControlEvent,
+  SandboxRespondMessage,
+  SandboxResponse,
+} from '../sandbox/types';

package/src/internal/tools.ts

@@ -0,0 +1,48 @@
+/**
+ * Public tools entrypoint (`@capekai/core/tools`).
+ *
+ * Exposes exactly the tool-registry and artifact identities the Jean2
+ * server consumes: scanning, listing, tool-path configuration, the tool
+ * source lifecycle, artifact download/verification/extraction, and install
+ * manifests. Every symbol resolves to the owning module's identity,
+ * identical to the compatibility barrel. S8a.
+ */
+
+export {
+  clearCache,
+  configureToolsPath,
+  getInstalledTool,
+  getTool,
+  hasUnscannedToolCache,
+  listInstalledTools,
+  listTools,
+  loadToolModule,
+  scanTools,
+} from '../tools/registry';
+export type { ToolRegistryResolver } from '../tools/registry';
+export { RETRIEVE_TOOL_OUTPUT_NAME } from '../tool-output/policy';
+export {
+  configureWorkspaceToolDiscovery,
+  getWorkspaceToolDiscovery,
+  type WorkspaceToolDiscovery,
+} from '../tools/tool-source';
+export {
+  ArtifactError,
+  downloadArtifact,
+  extractArtifact,
+  validateArtifactStructure,
+  verifyChecksum,
+} from '../tools/tool-artifact';
+export {
+  getManifestPath,
+  readInstallManifest,
+  writeInstallManifest,
+  type InstallManifest,
+} from '../tools/install-manifest';
+export {
+  stripVisualization,
+  extractVisualization,
+} from '../utils/strip-visualization';
+export {
+  listDomainToolFallbackDefinitions,
+} from '../runtime/domain-tool-source';