cognitive-core 0.1.0 → 0.1.2

package/src/types/config.ts

@@ -159,6 +159,20 @@ export const ExecutionConfigSchema = z.object({
 
 export type ExecutionConfig = z.infer<typeof ExecutionConfigSchema>;
 
+/**
+ * Compute provider configuration
+ */
+export const ComputeProviderConfigSchema = z.object({
+  /** Default cost tier preference */
+  defaultCostTier: z.enum(['free', 'low', 'medium', 'high']).default('low'),
+  /** Default location preference */
+  defaultLocation: z.enum(['local', 'remote', 'any']).default('local'),
+  /** Fallback to any available source if preferred not available */
+  allowFallback: z.boolean().default(true),
+});
+
+export type ComputeProviderConfig = z.infer<typeof ComputeProviderConfigSchema>;
+
 /**
  * Refinement configuration
  */
@@ -253,6 +267,24 @@ export const SkillLibraryConfigSchema = z.object({
 
 export type SkillLibraryConfig = z.infer<typeof SkillLibraryConfigSchema>;
 
+/**
+ * Agentic Task Runner configuration
+ */
+export const AgenticTaskRunnerConfigSchema = z.object({
+  /** Cleanup workspaces after completion */
+  cleanupWorkspaces: z.boolean().default(true),
+  /** Keep workspaces for failed tasks (for debugging) */
+  keepFailedWorkspaces: z.boolean().default(true),
+  /** Maximum concurrent analysis agents */
+  maxConcurrentAgents: z.number().default(3),
+  /** Stale workspace cleanup threshold in milliseconds */
+  staleWorkspaceMaxAgeMs: z.number().default(3600_000),
+  /** Base directory for workspaces (defaults to os.tmpdir()) */
+  workspaceBaseDir: z.string().optional(),
+});
+
+export type AgenticTaskRunnerConfig = z.infer<typeof AgenticTaskRunnerConfigSchema>;
+
 /**
  * MCP Server configuration
  */
@@ -277,6 +309,208 @@ export const MCPServerConfigSchema = z.object({
 
 export type MCPServerConfig = z.infer<typeof MCPServerConfigSchema>;
 
+/**
+ * Compression configuration for team trajectory ingestion
+ */
+export const CompressionConfigSchema = z.object({
+  /** Maximum tokens per agent after compression */
+  maxTokensPerAgent: z.number().default(5000),
+  /** Preserve interaction boundary steps at full fidelity */
+  preserveInteractionBoundaries: z.boolean().default(true),
+  /** Minimum consecutive non-key steps before folding */
+  foldThreshold: z.number().default(5),
+  /** Maximum ratio of steps to mark as critical */
+  maxCriticalRatio: z.number().default(0.25),
+  /** Score threshold for critical steps */
+  criticalStepThreshold: z.number().default(0.3),
+  /** Score threshold for critical interactions */
+  criticalInteractionThreshold: z.number().default(0.3),
+});
+
+export type CompressionConfig = z.infer<typeof CompressionConfigSchema>;
+
+/**
+ * Team-aware learning configuration
+ */
+export const TeamLearningConfigSchema = z.object({
+  /** Enable team-aware learning */
+  enabled: z.boolean().default(false),
+  /** Minimum team trajectories before batch learning */
+  minTeamTrajectories: z.number().default(5),
+  /** Similarity threshold for team playbook deduplication */
+  deduplicationThreshold: z.number().min(0).max(1).default(0.85),
+  /** Weight of structural metrics in analysis (0 = ignore, 1 = metrics only) */
+  metricsWeight: z.number().min(0).max(1).default(0.3),
+  /** Maximum team experiences to store */
+  maxTeamExperiences: z.number().default(200),
+  /** Maximum team playbooks to store */
+  maxTeamPlaybooks: z.number().default(50),
+  /** Maximum role playbooks to store */
+  maxRolePlaybooks: z.number().default(100),
+  /** Analysis agent timeout in milliseconds */
+  analysisTimeout: z.number().default(300_000),
+  /** Extraction agent timeout in milliseconds */
+  extractionTimeout: z.number().default(600_000),
+  /** Compression settings for trajectory ingestion */
+  compression: CompressionConfigSchema.default({}),
+});
+
+export type TeamLearningConfig = z.infer<typeof TeamLearningConfigSchema>;
+
+/**
+ * Knowledge Bank confidence model configuration
+ */
+export const ConfidenceConfigSchema = z.object({
+  /** Initial confidence for extracted observations */
+  extractedInitial: z.number().min(0).max(1).default(0.3),
+  /** Initial confidence for agent-authored notes */
+  agentAuthoredInitial: z.number().min(0).max(1).default(0.5),
+  /** EMA alpha for reinforcement */
+  reinforcementAlpha: z.number().min(0).max(1).default(0.1),
+  /** Confidence reduction on contradiction */
+  contradictionPenalty: z.number().min(0).max(1).default(0.3),
+  /** Daily confidence decay rate for unvalidated knowledge */
+  dailyDecayRate: z.number().min(0).max(0.1).default(0.001),
+  /** Confidence below which to mark as stale */
+  staleThreshold: z.number().min(0).max(1).default(0.2),
+  /** Days without validation before decay begins */
+  decayGracePeriodDays: z.number().default(90),
+});
+
+export type ConfidenceConfig = z.infer<typeof ConfidenceConfigSchema>;
+
+/**
+ * Knowledge Bank graph overlay configuration
+ */
+export const GraphConfigSchema = z.object({
+  /** Which graph layers to enable */
+  enabledLayers: z
+    .array(z.enum(['semantic', 'temporal', 'causal', 'entity']))
+    .default(['semantic']),
+  /** Whether to auto-infer temporal edges from timestamps */
+  inferTemporalEdges: z.boolean().default(true),
+  /** Whether to auto-infer causal edges from failure-recovery patterns */
+  inferCausalEdges: z.boolean().default(true),
+  /** Whether to auto-infer entity edges from shared entity tags */
+  inferEntityEdges: z.boolean().default(true),
+  /** Split layer files by domain when node count exceeds this */
+  domainSplitThreshold: z.number().default(500),
+  /** Promote to SQLite when total edge count exceeds this */
+  sqlitePromotionThreshold: z.number().default(10000),
+});
+
+export type GraphConfigType = z.infer<typeof GraphConfigSchema>;
+
+/**
+ * Knowledge Bank defragmentation configuration
+ */
+export const DefragConfigSchema = z.object({
+  /** Minimum inbox items before triggering defrag */
+  minInboxItems: z.number().default(5),
+  /** Whether to auto-consolidate observations into entities */
+  autoConsolidate: z.boolean().default(true),
+  /** Minimum observations about an entity before consolidation */
+  consolidationThreshold: z.number().default(3),
+  /** Whether to auto-regenerate domain summaries */
+  autoRegenerateSummaries: z.boolean().default(true),
+  /** Use LLM for summary generation (vs heuristic concatenation) */
+  llmSummaryGeneration: z.boolean().default(false),
+  /** Whether to auto-resolve simple contradictions */
+  autoResolveContradictions: z.boolean().default(false),
+});
+
+export type DefragConfig = z.infer<typeof DefragConfigSchema>;
+
+/**
+ * Knowledge Bank extraction configuration
+ */
+export const KnowledgeExtractionConfigSchema = z.object({
+  /** Enable automatic knowledge extraction from trajectories */
+  enabled: z.boolean().default(true),
+  /** Use LLM-assisted extraction (vs heuristic only) */
+  useLlmExtraction: z.boolean().default(false),
+  /** Minimum trajectory attribution score for extraction */
+  minAttributionScore: z.number().min(0).max(1).default(0.3),
+});
+
+export type KnowledgeExtractionConfig = z.infer<typeof KnowledgeExtractionConfigSchema>;
+
+/**
+ * Knowledge Bank surfacing configuration
+ */
+export const KnowledgeSurfacingConfigSchema = z.object({
+  /** Include domain summaries in task context */
+  includeDomainSummaries: z.boolean().default(true),
+  /** Include entity notes in task context */
+  includeEntityNotes: z.boolean().default(true),
+  /** Maximum knowledge notes to surface per task */
+  maxNotesPerTask: z.number().default(5),
+  /** Maximum tokens for knowledge context */
+  maxTokensForKnowledge: z.number().default(1500),
+  /** Include evidence citations in surfaced notes */
+  includeEvidence: z.boolean().default(false),
+  /** Include graph links in surfaced notes */
+  includeLinks: z.boolean().default(false),
+});
+
+export type KnowledgeSurfacingConfig = z.infer<typeof KnowledgeSurfacingConfigSchema>;
+
+/**
+ * Knowledge Bank configuration
+ */
+export const KnowledgeBankConfigSchema = z.object({
+  /** Enable knowledge bank */
+  enabled: z.boolean().default(true),
+  /** Root directory for knowledge files (relative to storage.baseDir) */
+  memoryDir: z.string().default('memory'),
+  /** Extraction config */
+  extraction: KnowledgeExtractionConfigSchema.default({}),
+  /** Defragmentation config */
+  defrag: DefragConfigSchema.default({}),
+  /** Confidence model config */
+  confidence: ConfidenceConfigSchema.default({}),
+  /** Graph overlay config */
+  graph: GraphConfigSchema.default({}),
+  /** Surfacing config (independent from SkillLibrary) */
+  surfacing: KnowledgeSurfacingConfigSchema.default({}),
+  /** Whether to manage minimem-specific features (sync, versioning) */
+  minimemAware: z.boolean().default(true),
+});
+
+export type KnowledgeBankConfig = z.infer<typeof KnowledgeBankConfigSchema>;
+
+/**
+ * Session Bank configuration (Entire CLI integration)
+ */
+export const SessionBankConfigSchema = z.object({
+  /** Enable session bank integration */
+  enabled: z.boolean().default(false),
+  /** Orphan branch name */
+  branch: z.string().default('entire/checkpoints/v1'),
+  /** State directory (relative to storage.baseDir) */
+  stateDir: z.string().default('session-bank'),
+  /** Default outcome strategy for synthesis */
+  outcomeStrategy: z.enum(['summary', 'heuristic']).default('summary'),
+  /** Auto-ingest unprocessed sessions on init */
+  autoIngest: z.boolean().default(false),
+  /** Maximum sessions per auto-ingest batch */
+  maxIngestBatch: z.number().default(20),
+});
+
+export type SessionBankConfig = z.infer<typeof SessionBankConfigSchema>;
+
+/**
+ * Skill-tree storage configuration
+ */
+export const SkillTreeConfigSchema = z.object({
+  /** Enable automatic skill-tree publishing via SqliteStorageAdapter */
+  enabled: z.boolean().default(true),
+  /** Path to the SQLite database for skill storage (relative to storage.baseDir) */
+  dbPath: z.string().default('skills.db'),
+});
+
+export type SkillTreeConfig = z.infer<typeof SkillTreeConfigSchema>;
+
 /**
  * Main Atlas configuration
  */
@@ -299,6 +533,18 @@ export const AtlasConfigSchema = z.object({
   skillLibrary: SkillLibraryConfigSchema.default({}),
   /** MCP Server configuration */
   mcp: MCPServerConfigSchema.default({}),
+  /** Agentic Task Runner configuration */
+  agenticTasks: AgenticTaskRunnerConfigSchema.default({}),
+  /** Compute provider configuration */
+  compute: ComputeProviderConfigSchema.default({}),
+  /** Team-aware learning configuration */
+  teamLearning: TeamLearningConfigSchema.default({}),
+  /** Knowledge bank configuration */
+  knowledgeBank: KnowledgeBankConfigSchema.default({}),
+  /** Skill-tree storage configuration */
+  skillTree: SkillTreeConfigSchema.default({}),
+  /** Session bank configuration (Entire CLI integration) */
+  sessionBank: SessionBankConfigSchema.default({}),
 });
 
 export type AtlasConfig = z.infer<typeof AtlasConfigSchema>;
@@ -329,5 +575,11 @@ export function mergeConfig(
     refinement: { ...base.refinement, ...overrides.refinement },
     skillLibrary: { ...base.skillLibrary, ...overrides.skillLibrary },
     mcp: { ...base.mcp, ...overrides.mcp },
+    agenticTasks: { ...base.agenticTasks, ...overrides.agenticTasks },
+    compute: { ...base.compute, ...overrides.compute },
+    teamLearning: { ...base.teamLearning, ...overrides.teamLearning },
+    knowledgeBank: { ...base.knowledgeBank, ...overrides.knowledgeBank },
+    skillTree: { ...base.skillTree, ...overrides.skillTree },
+    sessionBank: { ...base.sessionBank, ...overrides.sessionBank },
   });
 }

package/src/types/dataclaw.ts

@@ -0,0 +1,99 @@
+import { z } from 'zod';
+
+// ============================================================================
+// DataClaw — types for the dataclaw JSONL trajectory export format
+// https://github.com/peteromallet/dataclaw
+//
+// DataClaw exports conversation histories from AI coding assistants
+// (Claude Code, Codex, Gemini CLI, OpenCode, etc.) into structured JSONL
+// datasets. Each line is one complete coding session.
+// ============================================================================
+
+/**
+ * A tool invocation within a dataclaw assistant message.
+ */
+export const DataclawToolUseSchema = z.object({
+  /** Tool name (e.g. "bash", "Read", "Write", "Grep", "exec_command") */
+  tool: z.string(),
+  /** Structured arguments passed to the tool */
+  input: z.record(z.unknown()).default({}),
+  /** Execution result — shape varies by source */
+  output: z.record(z.unknown()).default({}),
+  /** "success" or "error" */
+  status: z.string().default('success'),
+});
+
+export type DataclawToolUse = z.infer<typeof DataclawToolUseSchema>;
+
+/**
+ * A single conversation turn in a dataclaw session.
+ */
+export const DataclawMessageSchema = z.object({
+  /** "user" or "assistant" */
+  role: z.enum(['user', 'assistant']),
+  /** The text content of the message */
+  content: z.string().default(''),
+  /** Extended reasoning / chain-of-thought (optional, Claude-specific) */
+  thinking: z.string().nullable().optional(),
+  /** Tool invocations on assistant messages */
+  tool_uses: z.array(DataclawToolUseSchema).optional(),
+  /** ISO 8601 timestamp */
+  timestamp: z.string().nullable().optional(),
+});
+
+export type DataclawMessage = z.infer<typeof DataclawMessageSchema>;
+
+/**
+ * Aggregate statistics for a dataclaw session.
+ */
+export const DataclawStatsSchema = z.object({
+  user_messages: z.number().default(0),
+  assistant_messages: z.number().default(0),
+  tool_uses: z.number().default(0),
+  input_tokens: z.number().default(0),
+  output_tokens: z.number().default(0),
+});
+
+export type DataclawStats = z.infer<typeof DataclawStatsSchema>;
+
+/**
+ * A complete coding session — one line of the dataclaw JSONL export.
+ */
+export const DataclawSessionSchema = z.object({
+  /** Unique session identifier */
+  session_id: z.string(),
+  /** Project/directory name (anonymized) */
+  project: z.string().default(''),
+  /** AI model used (e.g. "claude-opus-4-6") */
+  model: z.string().default(''),
+  /** Source tool ("claude", "codex", "gemini", "opencode", "openclaw", "kimi", "custom") */
+  source: z.string().default(''),
+  /** Git branch active during the session */
+  git_branch: z.string().nullable().optional(),
+  /** ISO 8601 start time */
+  start_time: z.string().nullable().optional(),
+  /** ISO 8601 end time */
+  end_time: z.string().nullable().optional(),
+  /** Ordered conversation turns */
+  messages: z.array(DataclawMessageSchema).default([]),
+  /** Aggregate session stats */
+  stats: DataclawStatsSchema.optional(),
+});
+
+export type DataclawSession = z.infer<typeof DataclawSessionSchema>;
+
+/**
+ * Export-level metadata (metadata.json companion file).
+ */
+export const DataclawMetadataSchema = z.object({
+  sessions: z.number().default(0),
+  skipped: z.number().default(0),
+  redactions: z.number().default(0),
+  models: z.record(z.number()).default({}),
+  projects: z.array(z.string()).default([]),
+  total_input_tokens: z.number().default(0),
+  total_output_tokens: z.number().default(0),
+  exported_at: z.string().optional(),
+});
+
+export type DataclawMetadata = z.infer<typeof DataclawMetadataSchema>;

package/src/types/huggingface-transformers.d.ts

@@ -0,0 +1,12 @@
+// Type declaration for optional @huggingface/transformers dependency
+declare module "@huggingface/transformers" {
+  export function pipeline(
+    task: string,
+    model: string,
+    options?: Record<string, unknown>,
+  ): Promise<(input: string, options?: Record<string, unknown>) => Promise<{ data: Float32Array }>>;
+
+  export const env: {
+    cacheDir?: string;
+  };
+}

package/src/types/index.ts

@@ -85,6 +85,140 @@ export {
   createMetaStrategy,
 } from './meta.js';
 
+// Team trajectory types
+export {
+  type TeamTrajectory,
+  type TeamEvent,
+  type TeamEventType,
+  type InteractionEdge,
+  type CoordinationMetrics,
+  type MemberOutcome,
+  type TeamOutcome,
+  type InteractionType,
+  type InteractionTag,
+  type ExpectedInteractionPattern,
+  type TeamTrajectoryInput,
+  type MemberTrajectoryInput,
+  type MemberTrajectory,
+  type AgentInteraction,
+  type GraphStructuralMetrics,
+  createTeamTrajectory,
+  isTeamSuccessful,
+  buildInteractionGraph,
+  buildTeamTrajectory,
+} from './team-trajectory.js';
+
+// Team playbook types
+export {
+  type TeamPlaybook,
+  type TeamPlaybookApplicability,
+  type TeamCompositionGuidance,
+  type TeamRoleSpec,
+  type TeamCoordinationGuidance,
+  type TeamChannelSpec,
+  type InteractionPattern,
+  type TeamPlaybookVerification,
+  type TeamPlaybookEvolution,
+  type TeamRefinement,
+  type RolePlaybook,
+  type RoleTeamContext,
+  type RoleGuidance,
+  type RoleInteractionGuidance,
+  type RoleDecisionFramework,
+  type RolePlaybookEvolution,
+  type RolePlaybookReference,
+  type RelatedTaskPlaybook,
+  createTeamPlaybook,
+  createRolePlaybook,
+  getTeamPlaybookSuccessRate,
+  getRolePlaybookSuccessRate,
+} from './team-playbook.js';
+
+// Team meta-learning types
+export {
+  type TeamMetaObservation,
+  type FormationObservation,
+  type CompositionObservation,
+  type CoordinationObservation,
+  type TeamOutcomeObservation,
+  type TeamLessonsLearned,
+  type TeamMetaStrategy,
+  type TeamMetaCondition,
+  type TeamMetaAdjustment,
+  createTeamMetaObservation,
+  createTeamMetaStrategy,
+} from './team-meta.js';
+
+// Knowledge types
+export {
+  type KnowledgeNoteFrontmatter,
+  type KnowledgeNote,
+  type KnowledgeMatch,
+  type KnowledgeSource,
+  type KnowledgeLink,
+  type NoteType,
+  type LinkRelation,
+  type SourceOrigin,
+  type GraphLayerName,
+  type EntityUpdate,
+  type Contradiction,
+  type PlaybookLink as KnowledgePlaybookLink,
+  type NewLink,
+  type ExtractedKnowledge,
+  type InboxResult,
+  type DefragResult,
+  type DecayResult,
+  type KnowledgeStats,
+  KnowledgeNoteFrontmatterSchema,
+  NoteTypeSchema,
+  LinkRelationSchema,
+  GraphLayerNameSchema,
+  AllLinkRelations,
+  inferLayerFromRelation,
+  createObservation,
+  createEntityNote,
+  createDomainSummary,
+} from './knowledge.js';
+
+// Knowledge graph types
+export {
+  type GraphNode,
+  type GraphEdge,
+  type GraphLayer,
+  type KnowledgeMultiGraph,
+  type GraphLayerOperations,
+  type GraphNodeFilter,
+  type NeighborOptions,
+  type KnowledgeGraphManagerInterface,
+  type GraphConfig,
+  DEFAULT_GRAPH_CONFIG,
+  SEMANTIC_RELATIONS,
+  TEMPORAL_RELATIONS,
+  CAUSAL_RELATIONS,
+  ENTITY_RELATIONS,
+} from './knowledge-graph.js';
+
+// Trajectory source types
+export {
+  type TrajectorySource,
+  type TrajectoryWithAnalysis,
+  type TrajectoryLoadOptions,
+} from './trajectory-source.js';
+
+// DataClaw types (dataclaw JSONL trajectory exports)
+export {
+  type DataclawSession,
+  type DataclawMessage,
+  type DataclawToolUse,
+  type DataclawStats,
+  type DataclawMetadata,
+  DataclawSessionSchema,
+  DataclawMessageSchema,
+  DataclawToolUseSchema,
+  DataclawStatsSchema,
+  DataclawMetadataSchema,
+} from './dataclaw.js';
+
 // Configuration types
 export {
   type CreditStrategy,
@@ -105,7 +239,25 @@ export {
   type SkillDemotionConfig,
   type SkillLibraryConfig,
   type MCPServerConfig,
+  type CompressionConfig,
+  type TeamLearningConfig,
+  type AgenticTaskRunnerConfig,
+  type KnowledgeBankConfig,
+  type KnowledgeExtractionConfig,
+  type KnowledgeSurfacingConfig,
+  type ConfidenceConfig,
+  type GraphConfigType,
+  type DefragConfig,
+  type SkillTreeConfig,
+  type SessionBankConfig,
   type AtlasConfig,
+  SessionBankConfigSchema,
+  KnowledgeBankConfigSchema,
+  KnowledgeExtractionConfigSchema,
+  KnowledgeSurfacingConfigSchema,
+  ConfidenceConfigSchema,
+  GraphConfigSchema,
+  DefragConfigSchema,
   CreditStrategySchema,
   PatternExtractorSchema,
   LearningConfigSchema,
@@ -124,6 +276,10 @@ export {
   SkillDemotionConfigSchema,
   SkillLibraryConfigSchema,
   MCPServerConfigSchema,
+  CompressionConfigSchema,
+  TeamLearningConfigSchema,
+  AgenticTaskRunnerConfigSchema,
+  SkillTreeConfigSchema,
   AtlasConfigSchema,
   createDefaultConfig,
   mergeConfig,