@stackbilt/aegis-core 0.1.0

package/src/kernel/scheduled/self-improvement.ts

@@ -0,0 +1,114 @@
+// Stub — full implementation not yet extracted to OSS
+// proposeToolsFromPatterns is live (v1.56.0)
+
+import { type EdgeEnv } from '../dispatch.js';
+import { createDynamicTool, listDynamicTools, invalidateToolCache } from '../dynamic-tools.js';
+
+export const DEFAULT_WATCH_REPOS = [
+  'aegis',
+  'demo_app_v2',
+  'charter',
+  'img-forge',
+  'example-auth',
+  'bizops-copilot',
+];
+
+export function getWatchRepos(githubRepo: string): string[] {
+  const org = githubRepo.split('/')[0];
+  return DEFAULT_WATCH_REPOS.map(repo => `${org}/${repo}`);
+}
+
+export async function runSelfImprovementAnalysis(_env: EdgeEnv): Promise<void> {
+  // Stub — full implementation provided by consuming app via ScheduledTaskPlugin
+}
+
+export async function runSelfImprovementHousekeeping(env: EdgeEnv): Promise<void> {
+  // Recurring prompt patterns → dynamic tool proposals
+  try {
+    await proposeToolsFromPatterns(env);
+  } catch {
+    // Non-fatal — table may not exist yet
+  }
+}
+
+export async function runInfraComplianceCheck(_env: EdgeEnv): Promise<void> {
+  // Stub — full implementation provided by consuming app via ScheduledTaskPlugin
+}
+
+// ─── Dynamic Tool Auto-Proposal ─────────────────────────────
+// Scans completed tasks for recurring prompt structures.
+// If 3+ tasks share a common prompt prefix (first 100 chars),
+// proposes a dynamic tool that parameterizes the varying parts.
+
+const TOOL_PROPOSAL_MIN_CLUSTER = 3;
+const TOOL_PROPOSAL_PREFIX_LEN = 100;
+
+async function proposeToolsFromPatterns(env: EdgeEnv): Promise<void> {
+  // Get recent successful tasks
+  const tasks = await env.db.prepare(`
+    SELECT title, prompt, category, repo FROM cc_tasks
+    WHERE status = 'completed' AND completed_at > datetime('now', '-14 days')
+    ORDER BY completed_at DESC LIMIT 50
+  `).all<{ title: string; prompt: string; category: string; repo: string }>();
+
+  if (tasks.results.length < TOOL_PROPOSAL_MIN_CLUSTER) return;
+
+  // Cluster by prompt prefix (first N chars, normalized)
+  const clusters = new Map<string, Array<{ title: string; prompt: string; category: string; repo: string }>>();
+  for (const task of tasks.results) {
+    const prefix = task.prompt.slice(0, TOOL_PROPOSAL_PREFIX_LEN).toLowerCase().replace(/\s+/g, ' ').trim();
+    const existing = clusters.get(prefix) ?? [];
+    existing.push(task);
+    clusters.set(prefix, existing);
+  }
+
+  // Check existing dynamic tools to avoid duplicates
+  const existingTools = await listDynamicTools(env.db, { limit: 100 });
+  const existingNames = new Set(existingTools.map(t => t.name));
+
+  let created = 0;
+  for (const [prefix, group] of clusters) {
+    if (group.length < TOOL_PROPOSAL_MIN_CLUSTER) continue;
+
+    // Derive a tool name from the category and common words
+    const category = group[0].category;
+    const words = prefix.split(/\s+/).filter(w => w.length > 3).slice(0, 3);
+    const toolName = `auto_${category}_${words.join('_')}`.replace(/[^a-z0-9_]/g, '').slice(0, 49);
+
+    if (existingNames.has(toolName) || toolName.length < 8) continue;
+
+    // Build a template from the common prefix + a {{details}} variable for the varying part
+    const commonPrefix = group[0].prompt.slice(0, TOOL_PROPOSAL_PREFIX_LEN);
+    const template = `${commonPrefix}\n\nSpecific details: {{details}}\n\nTarget repo: {{repo}}`;
+
+    try {
+      await createDynamicTool(env.db, {
+        name: toolName,
+        description: `Auto-proposed: ${group.length} similar ${category} tasks detected (e.g. "${group[0].title.slice(0, 60)}")`,
+        input_schema: JSON.stringify({
+          type: 'object',
+          properties: {
+            details: { type: 'string', description: 'Specific details for this task' },
+            repo: { type: 'string', description: 'Target repository' },
+          },
+          required: ['details'],
+        }),
+        prompt_template: template,
+        executor: 'workers_ai',
+        created_by: 'self_improvement',
+        status: 'draft',
+        ttl_days: 14,
+      });
+      created++;
+      existingNames.add(toolName);
+      console.log(`[self-improvement] Proposed dynamic tool: ${toolName} (${group.length} similar tasks)`);
+    } catch {
+      // Duplicate name or other constraint — skip
+    }
+  }
+
+  if (created > 0) {
+    invalidateToolCache();
+    console.log(`[self-improvement] Proposed ${created} dynamic tool(s) from recurring task patterns`);
+  }
+}

package/src/kernel/scheduled/social-engage.ts

@@ -0,0 +1,175 @@
+// Social Engagement — autonomous Bluesky interaction
+// Runs every 6 hours. Likes replies, follows back real accounts,
+// replies to substantive comments with Workers AI.
+
+import { type EdgeEnv } from '../dispatch.js';
+import {
+  getNotifications,
+  likePost,
+  followAccount,
+  getProfile,
+  postToBluesky,
+  type BlueskyNotification,
+} from '../../bluesky.js';
+
+// ─── Guardrails ─────────────────────────────────────────────
+
+const MAX_ACTIONS_PER_RUN = 10;       // Rate limit — don't spam
+const MIN_FOLLOWER_POSTS = 3;         // Skip accounts with <3 posts (likely bots)
+const NOTIFICATION_WINDOW_MS = 48 * 60 * 60 * 1000; // Only engage with last 48h
+
+// Patterns that indicate bot/spam accounts
+const SPAM_PATTERNS = [
+  /^follow.*back/i,
+  /crypto.*airdrop/i,
+  /onlyfans/i,
+  /dm.*me/i,
+  /free.*money/i,
+];
+
+function isLikelySpam(notification: BlueskyNotification): boolean {
+  const text = notification.text ?? '';
+  const name = notification.author.displayName ?? '';
+  return SPAM_PATTERNS.some(p => p.test(text) || p.test(name));
+}
+
+// ─── Main ───────────────────────────────────────────────────
+
+export async function runSocialEngagement(env: EdgeEnv): Promise<void> {
+  // Time gate: every 6 hours (01, 07, 13, 19 UTC) — offset from entropy (00, 06, 12, 18)
+  const hour = new Date().getUTCHours();
+  if (hour % 6 !== 1) return;
+
+  if (!env.blueskyAppPassword) {
+    console.log('[social-engage] No BLUESKY_APP_PASSWORD, skipping');
+    return;
+  }
+
+  const handle = env.blueskyHandle ?? 'your-handle.bsky.social';
+
+  // Cooldown: check last run via web_events
+  const lastRun = await env.db.prepare(
+    "SELECT received_at FROM web_events WHERE event_id = 'social_engage'"
+  ).first<{ received_at: string }>();
+
+  if (lastRun) {
+    const elapsed = Date.now() - new Date(lastRun.received_at + 'Z').getTime();
+    if (elapsed < 5 * 60 * 60 * 1000) return; // 5h cooldown
+  }
+
+  let notifications: BlueskyNotification[];
+  try {
+    notifications = await getNotifications(handle, env.blueskyAppPassword, 50);
+  } catch (err) {
+    console.error('[social-engage] Failed to fetch notifications:', err instanceof Error ? err.message : String(err));
+    return;
+  }
+
+  if (notifications.length === 0) {
+    console.log('[social-engage] No notifications');
+    await updateWatermark(env.db);
+    return;
+  }
+
+  // Filter to recent notifications only
+  const cutoff = Date.now() - NOTIFICATION_WINDOW_MS;
+  const recent = notifications.filter(n =>
+    new Date(n.indexedAt).getTime() > cutoff && !isLikelySpam(n)
+  );
+
+  let actions = 0;
+  const liked = new Set<string>();
+  const followed = new Set<string>();
+
+  for (const n of recent) {
+    if (actions >= MAX_ACTIONS_PER_RUN) break;
+
+    // ─── Like replies to our posts ────────────────────────
+    if (n.reason === 'reply' && n.uri && n.cid && !liked.has(n.uri)) {
+      try {
+        await likePost(handle, env.blueskyAppPassword, n.uri, n.cid);
+        liked.add(n.uri);
+        actions++;
+        console.log(`[social-engage] Liked reply from @${n.author.handle}`);
+      } catch { /* skip — might already be liked */ }
+    }
+
+    // ─── Like quote posts ─────────────────────────────────
+    if (n.reason === 'quote' && n.uri && n.cid && !liked.has(n.uri)) {
+      try {
+        await likePost(handle, env.blueskyAppPassword, n.uri, n.cid);
+        liked.add(n.uri);
+        actions++;
+        console.log(`[social-engage] Liked quote from @${n.author.handle}`);
+      } catch { /* skip */ }
+    }
+
+    // ─── Follow back real accounts ────────────────────────
+    if (n.reason === 'follow' && n.author.did && !followed.has(n.author.did)) {
+      try {
+        const profile = await getProfile(n.author.handle);
+        if (profile.postsCount >= MIN_FOLLOWER_POSTS) {
+          await followAccount(handle, env.blueskyAppPassword, n.author.did);
+          followed.add(n.author.did);
+          actions++;
+          console.log(`[social-engage] Followed back @${n.author.handle} (${profile.postsCount} posts)`);
+        } else {
+          console.log(`[social-engage] Skipped follow-back @${n.author.handle} (${profile.postsCount} posts — below threshold)`);
+        }
+      } catch { /* skip — might already follow */ }
+    }
+
+    // ─── Reply to substantive comments (Workers AI) ───────
+    if (n.reason === 'reply' && n.text && n.text.length > 40 && env.ai && actions < MAX_ACTIONS_PER_RUN) {
+      try {
+        const reply = await generateReply(env.ai, n.text, n.author.handle);
+        if (reply) {
+          // Need the parent post URI/CID for threading
+          // The notification uri IS the reply post — we need to reply TO it
+          await postToBluesky(handle, env.blueskyAppPassword, { text: reply });
+          actions++;
+          console.log(`[social-engage] Replied to @${n.author.handle}: ${reply.slice(0, 50)}...`);
+        }
+      } catch (err) {
+        console.warn(`[social-engage] Reply generation failed:`, err instanceof Error ? err.message : String(err));
+      }
+    }
+  }
+
+  await updateWatermark(env.db);
+  console.log(`[social-engage] Complete: ${actions} actions (${liked.size} likes, ${followed.size} follows)`);
+}
+
+async function updateWatermark(db: D1Database): Promise<void> {
+  await db.prepare(
+    "INSERT OR REPLACE INTO web_events (event_id, received_at) VALUES ('social_engage', datetime('now'))"
+  ).run();
+}
+
+// ─── Reply Generation ───────────────────────────────────────
+
+async function generateReply(
+  ai: Ai,
+  incomingText: string,
+  authorHandle: string,
+): Promise<string | null> {
+  const result = await ai.run('@cf/meta/llama-3.1-8b-instruct' as Parameters<Ai['run']>[0], {
+    messages: [
+      {
+        role: 'system',
+        content: `You are the operator's social media voice. Direct, builder-energy, anti-corporate. No emoji spam. No "excited to announce." Keep replies under 200 chars. Be genuine and conversational. If you can't add value, return SKIP.`,
+      },
+      {
+        role: 'user',
+        content: `@${authorHandle} replied to our Bluesky post: "${incomingText}"\n\nWrite a brief, genuine reply. Return ONLY the reply text, or SKIP if there's nothing meaningful to add.`,
+      },
+    ],
+    max_tokens: 100,
+  }) as { response?: string };
+
+  const reply = result.response?.trim();
+  if (!reply || reply === 'SKIP' || reply.length < 5) return null;
+
+  // Safety: truncate to 300 chars (Bluesky limit)
+  return reply.length > 280 ? reply.slice(0, 277) + '...' : reply;
+}

package/src/kernel/scheduled/task-audit.ts

@@ -0,0 +1,60 @@
+// Task Audit Chain -- tamper-evident execution trail using hash chains.
+// D1-only mode (no R2). Hash chain provides tamper evidence; D1 stores full records.
+
+import { computeHash } from '../../lib/audit-chain/chain.js';
+import { GENESIS_HASH } from '../../lib/audit-chain/types.js';
+
+const NAMESPACE = 'task-runner';
+
+/** Read the latest chain head from D1, or GENESIS_HASH if empty. */
+export async function getChainHead(db: D1Database): Promise<string> {
+  const row = await db.prepare(
+    'SELECT hash FROM task_audit_chain WHERE namespace = ? ORDER BY created_at DESC LIMIT 1'
+  ).bind(NAMESPACE).first<{ hash: string }>();
+  return row?.hash ?? GENESIS_HASH;
+}
+
+/** Write a hash-linked audit record for a task execution. Returns new chain head. */
+export async function writeTaskAuditRecord(
+  db: D1Database,
+  opts: {
+    taskName: string;
+    status: 'ok' | 'error' | 'skipped';
+    durationMs: number;
+    errorMessage?: string;
+    chainHead: string;
+  },
+): Promise<string> {
+  const recordId = crypto.randomUUID();
+  const timestamp = new Date().toISOString();
+
+  // Build record data (without hash -- computed from this + prev_hash)
+  const recordData = {
+    record_id: recordId,
+    namespace: NAMESPACE,
+    event_type: `task.${opts.status}`,
+    prev_hash: opts.chainHead,
+    actor: 'aegis-scheduler',
+    timestamp,
+    payload: {
+      task_name: opts.taskName,
+      status: opts.status,
+      duration_ms: opts.durationMs,
+      ...(opts.errorMessage ? { error: opts.errorMessage } : {}),
+    },
+  };
+
+  const encoder = new TextEncoder();
+  const recordBytes = encoder.encode(JSON.stringify(recordData));
+  const hash = await computeHash(opts.chainHead, recordBytes);
+
+  await db.prepare(`
+    INSERT INTO task_audit_chain (record_id, namespace, event_type, hash, prev_hash, actor, timestamp, payload)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+  `).bind(
+    recordId, NAMESPACE, `task.${opts.status}`, hash, opts.chainHead,
+    'aegis-scheduler', timestamp, JSON.stringify(recordData.payload),
+  ).run();
+
+  return hash;
+}

package/src/kernel/symbolic.ts

@@ -0,0 +1,156 @@
+// Symbolic Consultation — TarotScript service binding client
+// Structured serendipity: deterministic symbolic computation that surfaces
+// tensions analytical reasoning suppresses.
+//
+// See: artifacts/symbolic-consultation-protocol.md
+
+// ─── Types (mirrors TarotScript ReadingAnalysis) ─────────────────────────────
+
+export type Element = 'Fire' | 'Water' | 'Air' | 'Earth';
+
+export interface CardSummary {
+  position: string;
+  name: string;
+  arcana: 'major' | 'minor';
+  number: number;
+  suit: string | null;
+  element: Element;
+  orientation: 'upright' | 'reversed';
+  keywords: string[];
+  courtRank: string | null;
+}
+
+export interface DignityPair {
+  positions: [string, string];
+  cards: [string, string];
+  relationship: string;
+  elements: [Element, Element];
+  description: string;
+  score: number;
+}
+
+export interface ReadingAnalysis {
+  cards: CardSummary[];
+  elementalCensus: Record<Element, number>;
+  dominantElement: Element;
+  shadowDensity: { reversed: number; total: number; ratio: number };
+  dignities: DignityPair[];
+  courtCards: CardSummary[];
+  majorArcana: CardSummary[];
+  numerology: { sum: number; reduced: number; sephira: string; keyword: string };
+  tensions: Array<{ elements: [Element, Element]; counts: [number, number]; description: string }>;
+}
+
+export interface ReadingResult {
+  output: string;
+  facts: Record<string, unknown>;
+  spread: { name: string; positions: Record<string, unknown> } | null;
+  analysis: ReadingAnalysis | null;
+  seed: number;
+  receipt: { hash: string; script: string; querentId: string };
+}
+
+export type SpreadType = 'single' | 'three-card' | 'star' | 'horseshoe' | 'celtic-cross' | 'shadow-work' | 'dreaming';
+
+export interface SymbolicContext {
+  domain: 'product' | 'architecture' | 'hiring' | 'strategy' | 'operations' | 'reflection';
+  situation: string;
+  tensionsKnown?: string[];
+  timeframe?: 'immediate' | 'this-week' | 'this-quarter' | 'long-term';
+}
+
+// ─── Memory summary (what AEGIS stores per reading) ──────────────────────────
+
+export interface SymbolicMemoryEntry {
+  type: 'symbolic_consultation';
+  receiptHash: string;
+  seed: number;
+  spreadType: SpreadType;
+  intention: string;
+  dominantElement: Element;
+  shadowDensity: number;
+  topTensions: Array<{ pair: [Element, Element]; count: number }>;
+  sephira: string;
+  sephiraKeyword: string;
+  timestamp: string;
+}
+
+// ─── Client ──────────────────────────────────────────────────────────────────
+
+export async function runReading(
+  fetcher: Fetcher,
+  spreadType: SpreadType,
+  intention: string,
+  context?: SymbolicContext,
+  seed?: number,
+): Promise<ReadingResult> {
+  const response = await fetcher.fetch('https://internal/run', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      spreadType,
+      querent: {
+        id: 'aegis',
+        intention,
+        state: context ? {
+          domain: context.domain,
+          situation: context.situation,
+          tensions_known: context.tensionsKnown?.join(', '),
+          timeframe: context.timeframe,
+        } : undefined,
+      },
+      seed,
+      inscribe: true,
+    }),
+  });
+
+  if (!response.ok) {
+    const body = await response.text();
+    throw new Error(`TarotScript error ${response.status}: ${body}`);
+  }
+
+  return response.json() as Promise<ReadingResult>;
+}
+
+export function summarizeForMemory(
+  reading: ReadingResult,
+  spreadType: SpreadType,
+  intention: string,
+): SymbolicMemoryEntry {
+  const analysis = reading.analysis;
+  return {
+    type: 'symbolic_consultation',
+    receiptHash: reading.receipt.hash,
+    seed: reading.seed,
+    spreadType,
+    intention,
+    dominantElement: analysis?.dominantElement ?? 'Earth',
+    shadowDensity: analysis?.shadowDensity?.ratio ?? 0,
+    topTensions: (analysis?.tensions ?? []).slice(0, 3).map(t => ({
+      pair: t.elements,
+      count: t.counts[0] + t.counts[1],
+    })),
+    sephira: analysis?.numerology?.sephira ?? 'unknown',
+    sephiraKeyword: analysis?.numerology?.keyword ?? 'unknown',
+    timestamp: new Date().toISOString(),
+  };
+}
+
+export function formatSymbolicNote(reading: ReadingResult, spreadType: SpreadType): string {
+  const analysis = reading.analysis;
+  if (!analysis) return `Symbolic note (TarotScript): ${spreadType} reading completed, no analysis available.`;
+
+  const shadow = analysis.shadowDensity.ratio;
+  const readiness = shadow < 0.2 ? 'clear — act' : shadow < 0.5 ? 'partially hidden — proceed with awareness' : 'mostly concealed — may not be the moment to decide';
+
+  const cards = analysis.cards.map(c => `${c.name} (${c.orientation})`).join(', ');
+  const tensions = analysis.tensions.slice(0, 2).map(t => t.description).join('; ');
+
+  return [
+    `Symbolic note (TarotScript ${spreadType}):`,
+    `Cards: ${cards}`,
+    `Dominant element: ${analysis.dominantElement} | Shadow density: ${shadow.toFixed(2)} (${readiness})`,
+    `Numerology: ${analysis.numerology.sephira} — ${analysis.numerology.keyword}`,
+    tensions ? `Tensions: ${tensions}` : null,
+  ].filter(Boolean).join('\n');
+}

package/src/kernel/types.ts

@@ -0,0 +1,145 @@
+// ─── Channel ─────────────────────────────────────────────────
+
+import type { EpisodicOutcome, ProceduralStatus as ProceduralStatusEnum } from '../schema-enums.js';
+
+export type Channel = 'web' | 'cli' | 'internal';
+
+// ─── KernelIntent ────────────────────────────────────────────
+
+export interface KernelIntent {
+  source: {
+    channel: Channel;
+    threadId: string;
+  };
+  raw: string;
+  classified?: string;
+  complexity?: number;
+  needsTools?: boolean;
+  confidence?: number;
+  domain?: string;
+  domainConfidence?: number;
+  timestamp: number;
+  costCeiling: 'free' | 'cheap' | 'expensive';
+  classifierSource?: 'classify-cast' | 'workers-ai' | 'groq';
+}
+
+// ─── Memory Types ────────────────────────────────────────────
+
+export interface EpisodicEntry {
+  id?: number;
+  intent_class: string;
+  channel: string;
+  summary: string;
+  outcome: EpisodicOutcome;
+  cost: number;
+  latency_ms: number;
+  near_miss?: string | null;
+  classifier_confidence?: number;
+  reclassified?: boolean;
+  thread_id?: string | null;
+  executor?: string | null;
+  created_at?: string;
+}
+
+export type ProceduralStatus = ProceduralStatusEnum;
+
+export interface Refinement {
+  timestamp: number;
+  what: string;
+  why: string;
+  impact: 'pending' | 'positive' | 'negative';
+}
+
+export interface ProceduralEntry {
+  id?: number;
+  task_pattern: string;
+  executor: string;
+  executor_config: string;
+  success_count: number;
+  fail_count: number;
+  avg_latency_ms: number;
+  avg_cost: number;
+  status: ProceduralStatus;
+  consecutive_failures: number;
+  refinements: string;
+  last_used?: string;
+  candidate_executor?: string | null;
+  candidate_successes?: number;
+  created_at?: string;
+}
+
+export interface MemoryEntry {
+  id: number;
+  topic: string;
+  fact: string;
+  confidence: number;
+  source: string;
+  created_at: string;
+  valid_until: string | null;
+  superseded_by: number | null;
+  strength: number;
+  last_recalled_at: string | null;
+}
+
+// ─── Execution Plan ──────────────────────────────────────────
+
+export type Executor = 'claude' | 'groq' | 'direct' | 'claude_code' | 'workers_ai' | 'claude_opus' | 'gpt_oss' | 'composite' | 'tarotscript';
+
+export interface ExecutionPlan {
+  executor: Executor;
+  reasoning: string;
+  procedureId?: number;
+  costCeiling: 'free' | 'cheap' | 'expensive';
+}
+
+// ─── Cognitive State ─────────────────────────────────────────
+
+export interface CognitiveState {
+  version: number;
+  computed_at: string;
+
+  // Phase 1: Active narratives (max 10)
+  narratives: Array<{
+    arc: string;
+    title: string;
+    summary: string;
+    status: 'active' | 'stalled';
+    tension: string | null;
+    last_beat: string | null;
+    beat_count: number;
+  }>;
+
+  // Operational pulse
+  open_threads: number;
+  proposed_actions: number;
+
+  // Phase 2 (empty until populated)
+  activated_nodes: Array<{ label: string; type: string; activation: number }>;
+  active_projects: Array<{ project: string; status: string; top_blocker: string | null }>;
+
+  // Product portfolio (populated from BizOps project registry via heartbeat)
+  product_portfolio: Array<{ name: string; description: string; model: string; status: string; revenue?: string }>;
+
+  // Phase 3
+  latest_metacog: string | null;
+
+  // Stats
+  memory_count: number;
+  episode_count_24h: number;
+  last_heartbeat_severity: string | null;
+}
+
+// ─── Dispatch Result ─────────────────────────────────────────
+
+export interface DispatchResult {
+  text: string;
+  executor: Executor;
+  cost: number;
+  latency_ms: number;
+  procedureHit: boolean;
+  classification: string;
+  confidence?: number;
+  reclassified?: boolean;
+  probeResult?: 'agreed' | 'split' | 'escalated';
+  meta?: unknown;
+}