@pellux/goodvibes-agent 1.4.4 → 1.5.1

package/src/agent/skill-draft-runner.ts

@@ -0,0 +1,201 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import type { CommandContext } from '../input/command-registry.ts';
+import { buildLearningCandidates } from '../tools/agent-harness-learning-curator-proposals.ts';
+import type { AgentSkillRegistry } from './skill-registry.ts';
+import { proposeSkillDrafts } from './skill-draft-proposer.ts';
+import type { SkillDraftPayload } from './skill-draft-proposer.ts';
+
+// ---------------------------------------------------------------------------
+// Ledger types
+// ---------------------------------------------------------------------------
+
+export interface SkillDraftLedgerEntry {
+  /** Stable ledger entry id — matches the persisted skill id assigned by the registry. */
+  readonly skillId: string;
+  /** Kebab-slug name of the proposed skill. */
+  readonly name: string;
+  /** Learning candidate that originated this proposal. */
+  readonly candidateId: string;
+  /** ISO timestamp when the draft was proposed. */
+  readonly proposedAt: string;
+}
+
+interface SkillDraftLedgerFile {
+  readonly version: 1;
+  readonly entries: readonly SkillDraftLedgerEntry[];
+}
+
+const LEDGER_VERSION = 1 as const;
+
+// ---------------------------------------------------------------------------
+// Result type
+// ---------------------------------------------------------------------------
+
+export interface SkillDraftRunResult {
+  /** Number of new draft skills persisted this pass. */
+  readonly proposed: number;
+  /** Number of candidates that were eligible but skipped (dedup / secret). */
+  readonly skipped: number;
+  /** Entries written to the ledger this pass. */
+  readonly entries: readonly SkillDraftLedgerEntry[];
+  /** Skill ids created this pass. */
+  readonly skillIds: readonly string[];
+}
+
+// ---------------------------------------------------------------------------
+// Ledger I/O
+// ---------------------------------------------------------------------------
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function readLedger(ledgerPath: string): SkillDraftLedgerFile {
+  if (!existsSync(ledgerPath)) return { version: LEDGER_VERSION, entries: [] };
+  try {
+    const raw: unknown = JSON.parse(readFileSync(ledgerPath, 'utf-8'));
+    if (!isRecord(raw)) return { version: LEDGER_VERSION, entries: [] };
+    const entries = Array.isArray(raw.entries)
+      ? (raw.entries as unknown[])
+          .filter(isRecord)
+          .filter(
+            (e): e is Record<string, string> =>
+              typeof e.skillId === 'string' &&
+              typeof e.name === 'string' &&
+              typeof e.candidateId === 'string' &&
+              typeof e.proposedAt === 'string',
+          )
+          .map((e) => ({
+            skillId: e.skillId,
+            name: e.name,
+            candidateId: e.candidateId,
+            proposedAt: e.proposedAt,
+          } satisfies SkillDraftLedgerEntry))
+      : [];
+    return { version: LEDGER_VERSION, entries };
+  } catch {
+    return { version: LEDGER_VERSION, entries: [] };
+  }
+}
+
+function writeLedger(ledgerPath: string, file: SkillDraftLedgerFile): void {
+  mkdirSync(dirname(ledgerPath), { recursive: true });
+  const tmpPath = `${ledgerPath}.tmp`;
+  writeFileSync(tmpPath, `${JSON.stringify(file, null, 2)}\n`, 'utf-8');
+  renameSync(tmpPath, ledgerPath);
+}
+
+// ---------------------------------------------------------------------------
+// Ledger path resolution
+// ---------------------------------------------------------------------------
+
+/**
+ * Derive the ledger path from the registry's skills store path, placing the
+ * ledger file as a sibling: `.../skills/skill-draft-ledger.json`.
+ */
+function ledgerPathFromRegistry(registry: AgentSkillRegistry): string {
+  // AgentSkillRegistry exposes the store path via snapshot().path
+  const snapshot = registry.snapshot();
+  return snapshot.path.replace(/skills\.json$/, 'skill-draft-ledger.json');
+}
+
+// ---------------------------------------------------------------------------
+// Runner
+// ---------------------------------------------------------------------------
+
+/**
+ * Run one skill-draft-proposal pass.
+ *
+ * 1. Builds learning candidates from the current CommandContext.
+ * 2. Loads existing skill names and ledger (previously proposed names).
+ * 3. Calls proposeSkillDrafts (pure).
+ * 4. Persists each accepted draft via registry.create().
+ * 5. Appends new entries to the ledger.
+ *
+ * Returns a result summary. Never throws on partial failure — errors for
+ * individual proposals are caught so one bad candidate does not abort the pass.
+ */
+export function runSkillDraftProposer(
+  context: CommandContext,
+  registry: AgentSkillRegistry,
+): SkillDraftRunResult {
+  const ledgerPath = ledgerPathFromRegistry(registry);
+  const ledger = readLedger(ledgerPath);
+
+  // Build name sets for dedup
+  const existingSkillNames = new Set(
+    registry.list().map((s) => s.name.trim().toLowerCase()),
+  );
+  const previouslyProposedNames = new Set(
+    ledger.entries.map((e) => e.name.trim().toLowerCase()),
+  );
+
+  // Gather candidates from the live learning curator
+  const candidates = buildLearningCandidates(context);
+
+  // Count eligible before calling proposer so we can report skipped
+  const eligibleCount = candidates.filter(
+    (c) =>
+      (c.status === 'proposal-ready' || c.status === 'ready-to-promote') &&
+      c.proposalTarget === 'skill',
+  ).length;
+
+  const drafts = proposeSkillDrafts({ candidates, existingSkillNames, previouslyProposedNames });
+
+  const newEntries: SkillDraftLedgerEntry[] = [];
+  const skillIds: string[] = [];
+
+  for (const draft of drafts) {
+    try {
+      const skill = registry.create({
+        name: draft.name,
+        description: draft.description,
+        procedure: draft.procedure,
+        triggers: draft.triggers,
+        tags: draft.tags,
+        requirements: draft.requirements,
+        enabled: false, // hard rule: drafts are never auto-enabled
+        source: 'agent',
+        provenance: draft.provenance,
+      });
+      const entry: SkillDraftLedgerEntry = {
+        skillId: skill.id,
+        name: skill.name,
+        candidateId: draft.candidateId,
+        proposedAt: new Date().toISOString(),
+      };
+      newEntries.push(entry);
+      skillIds.push(skill.id);
+    } catch {
+      // Individual failures (e.g. name collision race) do not abort the pass
+    }
+  }
+
+  if (newEntries.length > 0) {
+    writeLedger(ledgerPath, {
+      version: LEDGER_VERSION,
+      entries: [...ledger.entries, ...newEntries],
+    });
+  }
+
+  return {
+    proposed: newEntries.length,
+    // skipped = eligible candidates that were not persisted (dedup + secret + cap + individual failures)
+    skipped: eligibleCount - newEntries.length,
+    entries: newEntries,
+    skillIds,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Ledger read helper — for harness tool inspection
+// ---------------------------------------------------------------------------
+
+/**
+ * Read the current ledger for inspection without running a proposal pass.
+ */
+export function readSkillDraftLedger(registry: AgentSkillRegistry): readonly SkillDraftLedgerEntry[] {
+  const ledgerPath = ledgerPathFromRegistry(registry);
+  return readLedger(ledgerPath).entries;
+}

package/src/agent/skill-registry.ts

@@ -3,6 +3,7 @@ import { delimiter, dirname, join } from 'node:path';
 import type { ShellPathService } from '@/runtime/index.ts';
 import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
 import { assertNoSecretLikeText } from './persona-registry.ts';
+import { parseSkillStandardMarkdown, writeSkillStandardFile } from './skill-standard.ts';
 import { formatAgentRecordReviewState } from './record-labels.ts';
 import type {
   AgentSkillBundleCreateInput,
@@ -63,6 +64,11 @@ function normalizeName(name: string): string {
   return name.trim().replace(/\s+/g, ' ');
 }
 
+/** Collapse embedded newlines and whitespace runs so a description is always a single line. */
+function normalizeDescription(description: string): string {
+  return description.replace(/[\r\n]+/g, ' ').replace(/\s+/g, ' ').trim();
+}
+
 function normalizeList(values: readonly string[] | undefined): string[] {
   const seen = new Set<string>();
   const result: string[] = [];
@@ -297,7 +303,7 @@ export class AgentSkillRegistry {
   public create(input: AgentSkillCreateInput): AgentSkillRecord {
     const store = this.readStore();
     const name = normalizeName(input.name);
-    const description = input.description.trim();
+    const description = normalizeDescription(input.description);
     const procedure = input.procedure.trim();
     this.validateRequired(name, description, procedure);
     const requirements = normalizeRequirements(input.requirements);
@@ -531,6 +537,35 @@ export class AgentSkillRegistry {
     return existing;
   }
 
+  /**
+   * Import a skill from the open skill standard format (SKILL.md).
+   * The skill is created with provenance 'skill-standard-import' and enabled=false (review-first policy).
+   * Throws if the file content is invalid or contains secret-looking text.
+   */
+  public importFromStandard(content: string): AgentSkillRecord {
+    const parsed = parseSkillStandardMarkdown(content);
+    if ('error' in parsed) throw new Error(parsed.error);
+    return this.create({
+      name: parsed.name,
+      description: parsed.description,
+      procedure: parsed.body,
+      enabled: false,
+      source: 'imported',
+      provenance: 'skill-standard-import',
+    });
+  }
+
+  /**
+   * Export one local skill by id to `<destDir>/<slug>/SKILL.md`.
+   * Throws if the skill is not found or the file already exists without overwrite=true.
+   * Returns the path written.
+   */
+  public exportToStandard(idOrName: string, destDir: string, overwrite = false): string {
+    const skill = this.get(idOrName);
+    if (!skill) throw new Error(`Unknown skill ${idOrName}`);
+    return writeSkillStandardFile(skill, destDir, overwrite);
+  }
+
   private validateRequired(name: string, description: string, procedure: string): void {
     if (!name) throw new Error('Skill name is required.');
     if (!description) throw new Error('Skill description is required.');

package/src/agent/skill-standard.ts

@@ -0,0 +1,99 @@
+import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { assertNoSecretLikeText } from './persona-registry.ts';
+import type { AgentSkillRecord } from './skill-registry-types.ts';
+
+export interface SkillStandardParsed {
+  readonly name: string;
+  readonly description: string;
+  readonly body: string;
+}
+
+export interface SkillStandardParseError {
+  readonly error: string;
+}
+
+function parseStandardFrontmatter(content: string): Record<string, string> {
+  const match = content.match(/^---\n([\s\S]*?)\n---/);
+  if (!match) return {};
+  const result: Record<string, string> = {};
+  for (const line of match[1].split('\n')) {
+    const colonIndex = line.indexOf(':');
+    if (colonIndex < 1) continue;
+    const key = line.slice(0, colonIndex).trim();
+    const value = line.slice(colonIndex + 1).trim();
+    if (key) result[key] = value;
+  }
+  return result;
+}
+
+/**
+ * Parse a SKILL.md in the open skill standard format.
+ * Frontmatter must contain `name` and `description`; extra keys are tolerated.
+ * Returns a parse error if either required key is absent or secret-looking content is found.
+ */
+export function parseSkillStandardMarkdown(content: string): SkillStandardParsed | SkillStandardParseError {
+  content = content.replace(/^/, '').replace(/\r\n/g, '\n');
+  const frontmatter = parseStandardFrontmatter(content);
+  const name = (frontmatter['name'] ?? '').trim();
+  const description = (frontmatter['description'] ?? '').trim();
+
+  if (!name) return { error: 'SKILL.md is missing required frontmatter field: name' };
+  if (!description) return { error: 'SKILL.md is missing required frontmatter field: description' };
+
+  const body = content.replace(/^---\n[\s\S]*?\n---\n?/, '').trim();
+
+  try {
+    assertNoSecretLikeText([name, description, body], 'Shared skill');
+  } catch (err) {
+    return { error: err instanceof Error ? err.message : 'Secret-looking content rejected.' };
+  }
+
+  return { name, description, body };
+}
+
+/**
+ * Render a local skill record to the open skill standard format.
+ * Produces `---\nname: ...\ndescription: ...\n---\n<body>\n`
+ * Round-trip safe: parse(render(skill)) recovers name, description, body.
+ */
+export function renderSkillStandardMarkdown(
+  skill: Pick<AgentSkillRecord, 'name' | 'description' | 'procedure'>,
+): string {
+  const nameLine = `name: ${skill.name}`;
+  // Collapse any embedded newlines/runs of whitespace so the description
+  // never spans more than one line and cannot break YAML frontmatter.
+  const safeDescription = skill.description.replace(/[\r\n]+/g, ' ').replace(/\s+/g, ' ').trim();
+  const descLine = `description: ${safeDescription}`;
+  const body = skill.procedure.trimEnd();
+  return `---\n${nameLine}\n${descLine}\n---\n${body}\n`;
+}
+
+/**
+ * Write a skill record as a SKILL.md inside `<destDir>/<slug>/SKILL.md`.
+ * Throws if the file already exists and `overwrite` is not true.
+ * Returns the path that was written.
+ */
+export function writeSkillStandardFile(
+  skill: Pick<AgentSkillRecord, 'name' | 'description' | 'procedure'>,
+  destDir: string,
+  overwrite = false,
+): string {
+  const slug = skill.name
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-|-$/g, '');
+  if (!slug) {
+    throw new Error('skill name produces an empty folder name');
+  }
+  const dir = join(destDir, slug);
+  const filePath = join(dir, 'SKILL.md');
+
+  if (!overwrite && existsSync(filePath)) {
+    throw new Error(`Skill file already exists at ${filePath}. Pass --overwrite to replace it.`);
+  }
+
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(filePath, renderSkillStandardMarkdown(skill), 'utf-8');
+  return filePath;
+}

package/src/agent/vibe-file.ts

@@ -3,6 +3,7 @@ import { dirname, isAbsolute, join, resolve } from 'node:path';
 import type { ShellPathService } from '@/runtime/index.ts';
 import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
 import { assertNoSecretLikeText } from './persona-registry.ts';
+import { parseMarkdownFrontmatter, stripMarkdownFrontmatter } from './markdown-frontmatter.ts';
 
 export type AgentVibeScope = 'project' | 'global';
 
@@ -64,23 +65,6 @@ type AgentVibePaths = Pick<ShellPathService,
   'workingDirectory' | 'homeDirectory' | 'resolveUserPath' | 'expandHomePath' | 'resolveWorkspacePath'
 >;
 
-function parseFrontmatter(content: string): Record<string, string> {
-  const match = content.match(/^---\n([\s\S]*?)\n---\n?/);
-  if (!match) return {};
-  const result: Record<string, string> = {};
-  for (const line of match[1].split('\n')) {
-    const [key, ...rest] = line.split(':');
-    if (key && rest.length > 0) result[key.trim()] = rest.join(':').trim();
-  }
-  return result;
-}
-
-function markdownBody(content: string): string {
-  const frontmatter = parseFrontmatter(content);
-  const body = (frontmatter.system_prompt ?? content.replace(/^---\n[\s\S]*?\n---\n?/, '')).trim();
-  return body;
-}
-
 function readVibeCandidate(path: string, scope: AgentVibeScope): AgentVibeFile | BlockedAgentVibeFile | null {
   if (!existsSync(path)) return null;
   let content = '';
@@ -94,8 +78,9 @@ function readVibeCandidate(path: string, scope: AgentVibeScope): AgentVibeFile |
     };
   }
 
-  const body = markdownBody(content);
-  if (!body) return {
+  const frontmatter = parseMarkdownFrontmatter(content);
+  const rawBody = (frontmatter.system_prompt ?? stripMarkdownFrontmatter(content)).trim();
+  if (!rawBody) return {
     path,
     scope,
     reason: 'File is empty after frontmatter.',
@@ -114,9 +99,9 @@ function readVibeCandidate(path: string, scope: AgentVibeScope): AgentVibeFile |
   return {
     path,
     scope,
-    body: body.length > MAX_VIBE_BODY_CHARS ? body.slice(0, MAX_VIBE_BODY_CHARS).trimEnd() : body,
-    frontmatter: parseFrontmatter(content),
-    truncated: body.length > MAX_VIBE_BODY_CHARS,
+    body: rawBody.length > MAX_VIBE_BODY_CHARS ? rawBody.slice(0, MAX_VIBE_BODY_CHARS).trimEnd() : rawBody,
+    frontmatter,
+    truncated: rawBody.length > MAX_VIBE_BODY_CHARS,
   };
 }
 

package/src/cli/completion.ts

@@ -55,7 +55,7 @@ const OPTIONS = [
   '--manual',
 ] as const;
 
-export function renderCompletion(shell: string | undefined, binary = 'goodvibes'): string {
+export function renderCompletion(shell: string | undefined, binary = 'goodvibes-agent'): string {
   const normalized = (shell ?? 'bash').toLowerCase();
   const words = [...COMMANDS, ...OPTIONS].join(' ');
 

package/src/cli/config-overrides.ts

@@ -13,7 +13,14 @@ type RuntimeOnlyConfigManager = {
 };
 
 function mutableConfig(configManager: ConfigManager): Record<string, unknown> {
-  return (configManager as unknown as RuntimeOnlyConfigManager).config;
+  const cast = configManager as unknown as RuntimeOnlyConfigManager;
+  if (!cast.config || typeof cast.config !== 'object') {
+    throw new Error(
+      'ConfigManager.config private field is missing or was renamed in the SDK. ' +
+      'Update setRuntimeOnlyConfigValue to use the correct field name.',
+    );
+  }
+  return cast.config;
 }
 
 function setRuntimeOnlyConfigValue(configManager: ConfigManager, key: ConfigKey, value: unknown): void {
@@ -158,6 +165,8 @@ export function applyRuntimeFeatureFlagOverrides(
   for (const feature of options.disableFeatures) {
     flags[feature] = 'disabled' satisfies PersistedFlagState;
   }
+  // Write the entire featureFlags category at once to preserve the exact shape getCategory expects.
+  // mutableConfig() validates the 'config' field exists and throws loudly if the SDK renames it.
   mutableConfig(configManager).featureFlags = flags;
 }
 

package/src/cli/redaction.ts

@@ -25,9 +25,14 @@ export interface RedactedConfigResult<T> {
   readonly redactedPaths: readonly string[];
 }
 
+// Redaction rule for sensitive config paths:
+// - Non-string values: redact if truthy (i.e. non-null, non-undefined, non-zero, non-false).
+//   Rationale: zero and false are never meaningful secrets; null/undefined mean absent.
+// - String values: redact non-empty strings that are not goodvibes:// secret refs.
+//   Rationale: empty string means unset; secret refs are safe placeholders, not raw values.
 function shouldRedactValue(path: string, value: unknown): boolean {
   if (!isSensitiveConfigPath(path)) return false;
-  if (typeof value !== 'string') return value !== undefined && value !== null;
+  if (typeof value !== 'string') return value !== null && value !== undefined && Boolean(value);
   if (value.trim().length === 0) return false;
   if (value.startsWith('goodvibes://secrets/')) return false;
   return true;
@@ -64,10 +69,17 @@ export function redactConfig<T>(config: T): RedactedConfigResult<T> {
 }
 
 export function redactText(input: string): string {
-  let output = input.replace(
-    /\b([A-Za-z0-9_]*(?:token|secret|password|api[_-]?key|key)[A-Za-z0-9_]*\s*=\s*)([^ \t\r\n"'`]+)/gi,
-    `$1${REDACTED_VALUE}`,
-  );
+  // Assignment form: keyword=value — anchored so 'monkey=' and 'donkey=' do NOT match.
+  // Matches: token=, access_token=, api_key=, api-key=, secret=, password= and colon form token: value
+  let output = input
+    .replace(
+      /(?<![A-Za-z])(?:access_token|api[_-]?key|secret|password|token)\s*=\s*([^ \t\r\n"'`]+)/gi,
+      (m, val) => m.slice(0, m.length - val.length) + REDACTED_VALUE,
+    )
+    .replace(
+      /(?<![A-Za-z])(?:access_token|api[_-]?key|secret|password|token)\s*:\s*([^ \t\r\n"'`]+)/gi,
+      (m, val) => m.slice(0, m.length - val.length) + REDACTED_VALUE,
+    );
   for (const pattern of SECRET_LIKE_TEXT_PATTERNS) {
     output = output.replace(pattern, REDACTED_VALUE);
   }

package/src/config/provider-model.ts

@@ -4,7 +4,8 @@ export function getProviderIdFromModel(model: unknown): string {
   const raw = String(model ?? '').trim();
   if (!raw) return getProviderIdFromModel(DEFAULT_CONFIG.provider.model);
   const separator = raw.indexOf(':');
-  return separator > 0 ? raw.slice(0, separator) : raw;
+  // separator === 0 means a leading colon (e.g. ':foo') — treat as no provider specified
+  return separator > 0 ? raw.slice(0, separator) : getProviderIdFromModel(DEFAULT_CONFIG.provider.model);
 }
 
 export function getModelIdFromProviderModel(model: unknown): string {

package/src/config/secret-config.ts

@@ -3,6 +3,8 @@ import type { ConfigKey } from './index.ts';
 import type { SecretScope, SecretStorageMedium } from './secrets.ts';
 
 export const SECRET_CONFIG_KEYS = new Set<ConfigKey>([
+  // email section (app-layer extension, key is string-cast for ConfigKey compatibility)
+  'email.passwordRef' as unknown as ConfigKey,
   'surfaces.slack.signingSecret',
   'surfaces.slack.botToken',
   'surfaces.slack.appToken',
@@ -103,15 +105,20 @@ export async function persistSecretBackedConfigValue(
 ): Promise<string> {
   const update = buildSecretBackedConfigUpdate(configKey, rawValue);
   const scope = options.scope ?? 'user';
+  const medium = getSecretWriteMedium(configManager.get('storage.secretPolicy'));
+
+  // 1. Validate config write first. If setDynamic throws, no secret is written (avoids orphans).
+  configManager.setDynamic(configKey, update.configValue);
+
+  // 2. Write new secret only after config accepted it.
   if (update.secretKey && update.secretValue !== undefined && secretsManager) {
-    await secretsManager.set(update.secretKey, update.secretValue, {
-      scope,
-      medium: getSecretWriteMedium(configManager.get('storage.secretPolicy')),
-    });
+    await secretsManager.set(update.secretKey, update.secretValue, { scope, medium });
   }
+
+  // 3. Clear old secret — pass the same medium so plaintext-medium secrets are found for deletion.
   if (update.clearSecretKey && secretsManager?.delete) {
-    await secretsManager.delete(update.clearSecretKey, { scope });
+    await secretsManager.delete(update.clearSecretKey, { scope, medium });
   }
-  configManager.setDynamic(configKey, update.configValue);
+
   return update.configValue;
 }

package/src/core/activity-feed.ts

@@ -0,0 +1,97 @@
+/**
+ * ActivityFeed — the single ambient record of what the assistant has been doing.
+ *
+ * Replaces the old multi-panel system's SystemMessagesPanel as the sink for
+ * operational traffic (model switches, provider discovery, delivery results,
+ * background work updates). The Activity sidebar renders the most recent
+ * entries; high-priority messages additionally land in the conversation via
+ * SystemMessageRouter.
+ *
+ * Design rules:
+ * - Append-only ring buffer (oldest entries dropped past MAX_ENTRIES).
+ * - No focus, no selection, no scrolling state — this is a glanceable feed,
+ *   not an interactive widget. History beyond the visible window is available
+ *   through the conversation (high priority) and logs.
+ * - Subscribers are render invalidators only; they receive no payload.
+ */
+
+export type ActivityKind =
+  | 'status'     // runtime/system state changes (model switch, session save)
+  | 'tool'       // tool activity worth surfacing
+  | 'agent'      // background agent/delegation updates
+  | 'schedule'   // scheduled/automation work
+  | 'delivery'   // channel deliveries (ntfy, Slack, …)
+  | 'security'   // permission/trust events
+  | 'system';    // everything else
+
+export type ActivityPriority = 'high' | 'low';
+
+export interface ActivityEntry {
+  readonly at: number;
+  readonly kind: ActivityKind;
+  readonly priority: ActivityPriority;
+  readonly text: string;
+}
+
+const MAX_ENTRIES = 500;
+
+/** Map a bracket-tagged system message (e.g. "[Model] …") to an ActivityKind. */
+export function classifyActivityKind(text: string): ActivityKind {
+  const tag = /^\[([^\]]+)\]/.exec(text)?.[1]?.toLowerCase() ?? '';
+  if (/(schedule|automation|routine|reminder|watcher)/.test(tag)) return 'schedule';
+  if (/(channel|delivery|notify|ntfy|message)/.test(tag)) return 'delivery';
+  if (/(agent|delegat|task)/.test(tag)) return 'agent';
+  if (/(permission|security|trust|secret)/.test(tag)) return 'security';
+  if (/(tool|mcp)/.test(tag)) return 'tool';
+  if (/(model|provider|session|memory|recovery|compaction|config|setting)/.test(tag)) return 'status';
+  return 'system';
+}
+
+export class ActivityFeed {
+  private entries: ActivityEntry[] = [];
+  private listeners = new Set<() => void>();
+
+  push(text: string, priority: ActivityPriority = 'low', kind?: ActivityKind): void {
+    const trimmed = text.replace(/\s+/g, ' ').trim();
+    if (!trimmed) return;
+    this.entries.push({
+      at: Date.now(),
+      kind: kind ?? classifyActivityKind(trimmed),
+      priority,
+      text: trimmed,
+    });
+    if (this.entries.length > MAX_ENTRIES) {
+      this.entries.splice(0, this.entries.length - MAX_ENTRIES);
+    }
+    this.notify();
+  }
+
+  /** Most recent entries, newest first. */
+  latest(limit: number): readonly ActivityEntry[] {
+    if (limit <= 0) return [];
+    return this.entries.slice(-limit).reverse();
+  }
+
+  all(): readonly ActivityEntry[] {
+    return this.entries;
+  }
+
+  get count(): number {
+    return this.entries.length;
+  }
+
+  subscribe(listener: () => void): () => void {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+
+  private notify(): void {
+    for (const listener of this.listeners) {
+      try {
+        listener();
+      } catch {
+        // Render invalidators must never break the feed.
+      }
+    }
+  }
+}