@pellux/goodvibes-agent 0.1.1 → 0.1.3

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 0.1.3 - 2026-05-31
+
+- Added local Agent personas with `/personas`: create/list/search/show/use/review/stale/delete, secret-looking value rejection, active persona prompt injection, and operator workspace status.
+- Added local Agent skills with `/agent-skills` and `/skills local`: create/list/search/show/enable/disable/review/stale/delete, secret-looking value rejection, enabled skill prompt injection, and operator workspace status.
+- Kept persona and skill state Agent-local with no default Knowledge/Wiki or HomeGraph fallback.
+
+## 0.1.2 - 2026-05-30
+
+- Added `goodvibes-agent compat` for package SDK pin, external daemon version, auth presence, and isolated Agent Knowledge route readiness.
+- Added `goodvibes-agent knowledge ...` commands for the isolated `/api/goodvibes-agent/knowledge/*` environment with no default Knowledge/Wiki or HomeGraph fallback.
+- Added explicit GoodVibes TUI build delegation through `goodvibes-agent delegate` and `/delegate`; WRFC is requested only through explicit `--wrfc`, `/wrfc`, or `/review` delegation.
+- Removed the copied WRFC panel from the default Agent panel registry while preserving explicit TUI delegation for build/fix/review work.
+- Hardened the Agent release helper and CLI help output for the current Agent changelog and command set.
+
 ## 0.1.1 - 2026-05-30
 
 - Reissued the first public alpha package after the initial `0.1.0` registry publish produced an install-blocking npm packument inconsistency.

package/README.md

@@ -43,6 +43,15 @@ bun run publish:check
 
 Inside the Agent TUI, use `/agent`, `/home`, or `/operator` to open the operator workspace. It is the Agent-first fullscreen surface for setup, status, knowledge, local memory/skills, work-plan/approval review, automation observability, and explicit build delegation to GoodVibes TUI.
 
+Local Agent behavior is editable from the TUI:
+
+```text
+/personas create --name Research --description "Source-backed research" --body "Check sources, call out uncertainty, keep answers concise."
+/personas use research
+/agent-skills create --name "Morning Brief" --description "Daily briefing flow" --procedure "Check tasks, approvals, calendar, and unread state before summarizing." --enabled true
+/skills local list
+```
+
 ## Daemon Prerequisite
 
 Start or restart the daemon from GoodVibes TUI or the daemon host before launching Agent. Agent status and companion/knowledge routes connect to that external daemon, normally on `http://127.0.0.1:3421`.
@@ -59,7 +68,9 @@ Those commands should return explicit external-daemon guidance instead of mutati
 
 ## Product Boundary
 
-GoodVibes Agent owns the operator assistant surface: serial assistant flow, proactive safe actions, local memory/skills/personas until stable shared registries exist, Agent knowledge routes, companion chat, approvals/automation observability, and explicit build delegation.
+GoodVibes Agent owns the operator assistant surface: serial assistant flow, proactive safe actions, local memory/skills/personas, Agent knowledge routes, companion chat, approvals/automation observability, and explicit build delegation.
+
+Agent Knowledge/Wiki is its own product segment. Agent uses `/api/goodvibes-agent/knowledge/*` and must not fall back to default Knowledge/Wiki, HomeGraph, or Home Assistant routes.
 
 GoodVibes TUI owns coding execution: file edits, git/worktree workflows, coding panels, sandbox/QEMU UX, and WRFC execution. Agent may delegate explicit build/fix/review work to TUI through public daemon/session contracts; normal assistant chat must not use shared coding sessions.
 

package/docs/README.md

@@ -17,6 +17,8 @@ Important baseline constraints:
 - Agent depends on `@pellux/goodvibes-sdk@0.33.35`.
 - Agent connects to an externally managed daemon.
 - Agent does not start, stop, restart, install, uninstall, or own daemon/listener/web/service lifecycle.
+- Agent Knowledge/Wiki uses only `/api/goodvibes-agent/knowledge/*`; there is no default Knowledge/Wiki, HomeGraph, or Home Assistant fallback.
+- Local personas and Agent skills are stored under the Agent surface root and are injected only into the serial Agent conversation.
 - Normal assistant chat is not coding-session delegation.
 - Build/fix/review delegation to GoodVibes TUI must be explicit; WRFC is not the default Agent behavior.
 

package/docs/getting-started.md

@@ -1,6 +1,6 @@
 # Getting Started
 
-GoodVibes Agent `0.1.1` is the first installable public alpha of the personal operator assistant built on the GoodVibes TUI foundation.
+GoodVibes Agent `0.1.3` is the current installable public alpha of the personal operator assistant built on the GoodVibes TUI foundation.
 
 ## Requirements
 
@@ -37,6 +37,21 @@ bun run dev
 
 Once the TUI opens, run `/agent`, `/home`, or `/operator` to open the Agent operator workspace. That fullscreen workspace is the current front door for setup/config, knowledge status, local memory and skills, read-only work/approval/automation views, and explicit GoodVibes TUI build delegation.
 
+## Local Personas And Skills
+
+Personas and reusable Agent skills are local to GoodVibes Agent. They do not write into default Knowledge/Wiki or HomeGraph.
+
+```text
+/personas list
+/personas create --name Research --description "Source-backed research" --body "Check sources, call out uncertainty, keep answers concise."
+/personas use research
+/agent-skills create --name "Morning Brief" --description "Daily briefing flow" --procedure "Check tasks, approvals, calendar, and unread state before summarizing." --enabled true
+/agent-skills enabled
+/skills local list
+```
+
+The active persona and enabled Agent skills are injected into the main serial assistant conversation. They do not spawn background agents.
+
 ## External Daemon
 
 Start the daemon from GoodVibes TUI or the daemon host before using daemon-backed Agent features. Agent expects the daemon to expose the public operator/Agent routes, including:
@@ -45,6 +60,9 @@ Start the daemon from GoodVibes TUI or the daemon host before using daemon-backe
 - `/api/goodvibes-agent/knowledge/status`
 - `/api/goodvibes-agent/knowledge/ask`
 - `/api/goodvibes-agent/knowledge/search`
+- `/api/goodvibes-agent/knowledge/ingest/url`
+
+Agent Knowledge/Wiki is an Agent-owned product segment. Agent commands must not fall back to default Knowledge/Wiki, HomeGraph, or Home Assistant spaces.
 
 Agent lifecycle commands that would start or mutate daemon posture are blocked intentionally. Use `goodvibes-agent status`, `goodvibes-agent doctor`, and read-only surface checks for diagnostics.
 

package/docs/release-and-publishing.md

@@ -1,6 +1,6 @@
 # Release And Publishing
 
-GoodVibes Agent `0.1.1` is the first installable public alpha release.
+GoodVibes Agent `0.1.3` is the current installable public alpha release.
 
 ## Package Identity
 
@@ -39,6 +39,8 @@ Also run the package install smoke from a packed artifact. It must prove:
 
 Do not publish if package-facing docs or install commands refer to another package name, another executable, or Agent-owned daemon lifecycle.
 
+Do not publish if Agent Knowledge commands can fall back to default Knowledge/Wiki, HomeGraph, or Home Assistant routes. Agent Knowledge must use the isolated `/api/goodvibes-agent/knowledge/*` segment.
+
 Do not ship daemon binaries from this package. If Agent later gets compiled artifacts, they must use Agent artifact names and remain separate from daemon ownership.
 
 ## Near-Fork Baseline Rule

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "private": false,
   "description": "Near-fork GoodVibes operator assistant with the GoodVibes TUI shell, renderer, input, fullscreen workspace, and daemon-connected Agent product brain.",
   "type": "module",
@@ -18,6 +18,15 @@
     "!src/test",
     "!src/**/*.test.ts",
     "!src/**/__tests__",
+    "!src/daemon/**",
+    "!src/panels/diff-panel.ts",
+    "!src/panels/file-explorer-panel.ts",
+    "!src/panels/file-preview-panel.ts",
+    "!src/panels/git-panel.ts",
+    "!src/panels/sandbox-panel.ts",
+    "!src/panels/symbol-outline-panel.ts",
+    "!src/panels/worktree-panel.ts",
+    "!src/panels/wrfc-panel.ts",
     "scripts/check-bun.sh",
     "tsconfig.json",
     "README.md",

package/src/agent/persona-registry.ts

@@ -0,0 +1,379 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import type { ShellPathService } from '@/runtime/index.ts';
+import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
+
+export type AgentPersonaSource = 'user' | 'agent' | 'imported' | 'system';
+export type AgentPersonaReviewState = 'fresh' | 'reviewed' | 'stale';
+
+export interface AgentPersonaRecord {
+  readonly id: string;
+  readonly name: string;
+  readonly description: string;
+  readonly body: string;
+  readonly tags: readonly string[];
+  readonly triggers: readonly string[];
+  readonly source: AgentPersonaSource;
+  readonly provenance: string;
+  readonly reviewState: AgentPersonaReviewState;
+  readonly staleReason?: string;
+  readonly createdAt: string;
+  readonly updatedAt: string;
+  readonly reviewedAt?: string;
+}
+
+export interface AgentPersonaCreateInput {
+  readonly name: string;
+  readonly description: string;
+  readonly body: string;
+  readonly tags?: readonly string[];
+  readonly triggers?: readonly string[];
+  readonly source?: AgentPersonaSource;
+  readonly provenance?: string;
+}
+
+export interface AgentPersonaUpdateInput {
+  readonly name?: string;
+  readonly description?: string;
+  readonly body?: string;
+  readonly tags?: readonly string[];
+  readonly triggers?: readonly string[];
+  readonly provenance?: string;
+}
+
+export interface AgentPersonaSnapshot {
+  readonly path: string;
+  readonly personas: readonly AgentPersonaRecord[];
+  readonly activePersonaId: string | null;
+  readonly activePersona: AgentPersonaRecord | null;
+}
+
+interface PersonaStoreFile {
+  readonly version: 1;
+  readonly activePersonaId: string | null;
+  readonly personas: readonly AgentPersonaRecord[];
+}
+
+const STORE_VERSION = 1;
+const SECRET_PATTERNS: readonly RegExp[] = [
+  /-----BEGIN [A-Z ]*PRIVATE KEY-----/i,
+  /\bsk-[A-Za-z0-9_-]{16,}\b/,
+  /\bgh[pousr]_[A-Za-z0-9_]{16,}\b/i,
+  /\b(?:password|passwd|api[_-]?key|token|secret)\s*[:=]\s*\S{6,}/i,
+];
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+
+function readString(value: unknown, fallback = ''): string {
+  return typeof value === 'string' ? value : fallback;
+}
+
+function readStringArray(value: unknown): string[] {
+  if (!Array.isArray(value)) return [];
+  return value.filter((entry): entry is string => typeof entry === 'string').map((entry) => entry.trim()).filter(Boolean);
+}
+
+function normalizeName(name: string): string {
+  return name.trim().replace(/\s+/g, ' ');
+}
+
+function normalizeList(values: readonly string[] | undefined): string[] {
+  const seen = new Set<string>();
+  const result: string[] = [];
+  for (const value of values ?? []) {
+    const trimmed = value.trim();
+    if (!trimmed) continue;
+    const key = trimmed.toLowerCase();
+    if (seen.has(key)) continue;
+    seen.add(key);
+    result.push(trimmed);
+  }
+  return result;
+}
+
+function slugify(value: string): string {
+  const slug = value.trim().toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
+  return slug || 'persona';
+}
+
+function nowIso(): string {
+  return new Date().toISOString();
+}
+
+function containsSecretLikeText(text: string): boolean {
+  return SECRET_PATTERNS.some((pattern) => pattern.test(text));
+}
+
+export function assertNoSecretLikeText(fields: readonly string[]): void {
+  if (fields.some((field) => containsSecretLikeText(field))) {
+    throw new Error('Personas cannot store secret-looking values. Store a secret reference or remove the sensitive text.');
+  }
+}
+
+function parsePersona(value: unknown): AgentPersonaRecord | null {
+  if (!isRecord(value)) return null;
+  const id = readString(value.id).trim();
+  const name = normalizeName(readString(value.name));
+  const description = readString(value.description).trim();
+  const body = readString(value.body).trim();
+  if (!id || !name || !description || !body) return null;
+  const reviewState = value.reviewState === 'reviewed' || value.reviewState === 'stale' ? value.reviewState : 'fresh';
+  const source = value.source === 'agent' || value.source === 'imported' || value.source === 'system' ? value.source : 'user';
+  const staleReason = readString(value.staleReason).trim();
+  const reviewedAt = readString(value.reviewedAt).trim();
+  return {
+    id,
+    name,
+    description,
+    body,
+    tags: readStringArray(value.tags),
+    triggers: readStringArray(value.triggers),
+    source,
+    provenance: readString(value.provenance, source).trim() || source,
+    reviewState,
+    staleReason: staleReason || undefined,
+    createdAt: readString(value.createdAt, nowIso()),
+    updatedAt: readString(value.updatedAt, nowIso()),
+    reviewedAt: reviewedAt || undefined,
+  };
+}
+
+function parseStore(raw: string): PersonaStoreFile {
+  const parsed: unknown = JSON.parse(raw);
+  if (!isRecord(parsed)) return { version: STORE_VERSION, activePersonaId: null, personas: [] };
+  const personas = Array.isArray(parsed.personas)
+    ? parsed.personas.map(parsePersona).filter((entry): entry is AgentPersonaRecord => entry !== null)
+    : [];
+  const activePersonaId = readString(parsed.activePersonaId).trim() || null;
+  return {
+    version: STORE_VERSION,
+    activePersonaId: activePersonaId && personas.some((persona) => persona.id === activePersonaId) ? activePersonaId : null,
+    personas,
+  };
+}
+
+function formatStore(store: PersonaStoreFile): string {
+  return `${JSON.stringify(store, null, 2)}\n`;
+}
+
+export function personaStorePath(shellPaths: ShellPathService): string {
+  return shellPaths.resolveUserPath(GOODVIBES_AGENT_SURFACE_ROOT, 'personas', 'personas.json');
+}
+
+export class AgentPersonaRegistry {
+  public constructor(private readonly storePath: string) {}
+
+  public static fromShellPaths(shellPaths: ShellPathService): AgentPersonaRegistry {
+    return new AgentPersonaRegistry(personaStorePath(shellPaths));
+  }
+
+  public snapshot(): AgentPersonaSnapshot {
+    const store = this.readStore();
+    const activePersona = store.activePersonaId
+      ? store.personas.find((persona) => persona.id === store.activePersonaId) ?? null
+      : null;
+    return {
+      path: this.storePath,
+      personas: [...store.personas],
+      activePersonaId: activePersona?.id ?? null,
+      activePersona,
+    };
+  }
+
+  public list(): readonly AgentPersonaRecord[] {
+    return this.snapshot().personas;
+  }
+
+  public search(query: string): readonly AgentPersonaRecord[] {
+    const normalized = query.trim().toLowerCase();
+    if (!normalized) return this.list();
+    return this.list().filter((persona) => [
+      persona.id,
+      persona.name,
+      persona.description,
+      persona.body,
+      ...persona.tags,
+      ...persona.triggers,
+    ].some((field) => field.toLowerCase().includes(normalized)));
+  }
+
+  public get(idOrName: string): AgentPersonaRecord | null {
+    const lookup = idOrName.trim().toLowerCase();
+    if (!lookup) return null;
+    return this.list().find((persona) => persona.id.toLowerCase() === lookup || persona.name.toLowerCase() === lookup) ?? null;
+  }
+
+  public create(input: AgentPersonaCreateInput): AgentPersonaRecord {
+    const store = this.readStore();
+    const name = normalizeName(input.name);
+    const description = input.description.trim();
+    const body = input.body.trim();
+    this.validateRequired(name, description, body);
+    assertNoSecretLikeText([name, description, body, ...(input.tags ?? []), ...(input.triggers ?? [])]);
+    const duplicate = store.personas.find((persona) => persona.name.toLowerCase() === name.toLowerCase());
+    if (duplicate) throw new Error(`Persona already exists: ${duplicate.id}`);
+    const timestamp = nowIso();
+    const persona: AgentPersonaRecord = {
+      id: this.nextId(name, store.personas),
+      name,
+      description,
+      body,
+      tags: normalizeList(input.tags),
+      triggers: normalizeList(input.triggers),
+      source: input.source ?? 'user',
+      provenance: input.provenance?.trim() || input.source || 'user',
+      reviewState: 'fresh',
+      createdAt: timestamp,
+      updatedAt: timestamp,
+    };
+    this.writeStore({ ...store, personas: [...store.personas, persona] });
+    return persona;
+  }
+
+  public update(idOrName: string, input: AgentPersonaUpdateInput): AgentPersonaRecord {
+    const store = this.readStore();
+    const existing = this.findInStore(store, idOrName);
+    if (!existing) throw new Error(`Unknown persona: ${idOrName}`);
+    const name = input.name === undefined ? existing.name : normalizeName(input.name);
+    const description = input.description === undefined ? existing.description : input.description.trim();
+    const body = input.body === undefined ? existing.body : input.body.trim();
+    this.validateRequired(name, description, body);
+    assertNoSecretLikeText([name, description, body, ...(input.tags ?? []), ...(input.triggers ?? [])]);
+    const duplicate = store.personas.find((persona) => persona.id !== existing.id && persona.name.toLowerCase() === name.toLowerCase());
+    if (duplicate) throw new Error(`Persona already exists: ${duplicate.id}`);
+    const updated: AgentPersonaRecord = {
+      ...existing,
+      name,
+      description,
+      body,
+      tags: input.tags === undefined ? existing.tags : normalizeList(input.tags),
+      triggers: input.triggers === undefined ? existing.triggers : normalizeList(input.triggers),
+      provenance: input.provenance === undefined ? existing.provenance : input.provenance.trim() || existing.provenance,
+      reviewState: 'fresh',
+      staleReason: undefined,
+      reviewedAt: undefined,
+      updatedAt: nowIso(),
+    };
+    this.writeStore({
+      ...store,
+      personas: store.personas.map((persona) => persona.id === existing.id ? updated : persona),
+    });
+    return updated;
+  }
+
+  public setActive(idOrName: string): AgentPersonaRecord {
+    const store = this.readStore();
+    const persona = this.findInStore(store, idOrName);
+    if (!persona) throw new Error(`Unknown persona: ${idOrName}`);
+    this.writeStore({ ...store, activePersonaId: persona.id });
+    return persona;
+  }
+
+  public clearActive(): void {
+    const store = this.readStore();
+    this.writeStore({ ...store, activePersonaId: null });
+  }
+
+  public markReviewed(idOrName: string): AgentPersonaRecord {
+    const store = this.readStore();
+    const existing = this.findInStore(store, idOrName);
+    if (!existing) throw new Error(`Unknown persona: ${idOrName}`);
+    const updated: AgentPersonaRecord = {
+      ...existing,
+      reviewState: 'reviewed',
+      staleReason: undefined,
+      reviewedAt: nowIso(),
+      updatedAt: nowIso(),
+    };
+    this.writeStore({
+      ...store,
+      personas: store.personas.map((persona) => persona.id === existing.id ? updated : persona),
+    });
+    return updated;
+  }
+
+  public markStale(idOrName: string, reason: string): AgentPersonaRecord {
+    const store = this.readStore();
+    const existing = this.findInStore(store, idOrName);
+    if (!existing) throw new Error(`Unknown persona: ${idOrName}`);
+    const updated: AgentPersonaRecord = {
+      ...existing,
+      reviewState: 'stale',
+      staleReason: reason.trim() || 'Marked stale by user.',
+      updatedAt: nowIso(),
+    };
+    this.writeStore({
+      ...store,
+      personas: store.personas.map((persona) => persona.id === existing.id ? updated : persona),
+    });
+    return updated;
+  }
+
+  public deletePersona(idOrName: string): AgentPersonaRecord {
+    const store = this.readStore();
+    const existing = this.findInStore(store, idOrName);
+    if (!existing) throw new Error(`Unknown persona: ${idOrName}`);
+    this.writeStore({
+      ...store,
+      activePersonaId: store.activePersonaId === existing.id ? null : store.activePersonaId,
+      personas: store.personas.filter((persona) => persona.id !== existing.id),
+    });
+    return existing;
+  }
+
+  private validateRequired(name: string, description: string, body: string): void {
+    if (!name) throw new Error('Persona name is required.');
+    if (!description) throw new Error('Persona description is required.');
+    if (!body) throw new Error('Persona body is required.');
+  }
+
+  private nextId(name: string, personas: readonly AgentPersonaRecord[]): string {
+    const base = slugify(name);
+    const ids = new Set(personas.map((persona) => persona.id));
+    if (!ids.has(base)) return base;
+    for (let index = 2; index < 1000; index += 1) {
+      const candidate = `${base}-${index}`;
+      if (!ids.has(candidate)) return candidate;
+    }
+    throw new Error(`Could not allocate persona id for ${name}.`);
+  }
+
+  private findInStore(store: PersonaStoreFile, idOrName: string): AgentPersonaRecord | null {
+    const lookup = idOrName.trim().toLowerCase();
+    if (!lookup) return null;
+    return store.personas.find((persona) => persona.id.toLowerCase() === lookup || persona.name.toLowerCase() === lookup) ?? null;
+  }
+
+  private readStore(): PersonaStoreFile {
+    if (!existsSync(this.storePath)) return { version: STORE_VERSION, activePersonaId: null, personas: [] };
+    try {
+      return parseStore(readFileSync(this.storePath, 'utf-8'));
+    } catch (error) {
+      throw new Error(`Could not read Agent persona store: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+
+  private writeStore(store: PersonaStoreFile): void {
+    mkdirSync(dirname(this.storePath), { recursive: true });
+    const tmpPath = `${this.storePath}.tmp`;
+    writeFileSync(tmpPath, formatStore(store), 'utf-8');
+    renameSync(tmpPath, this.storePath);
+  }
+}
+
+export function buildActivePersonaPrompt(shellPaths: ShellPathService): string | null {
+  const active = AgentPersonaRegistry.fromShellPaths(shellPaths).snapshot().activePersona;
+  if (!active) return null;
+  return [
+    '## Active GoodVibes Agent Persona',
+    `Name: ${active.name}`,
+    `Description: ${active.description}`,
+    `Review state: ${active.reviewState}`,
+    '',
+    active.body,
+    '',
+    'Apply this persona inside the same serial assistant conversation. Do not spawn background agents because a persona is active.',
+  ].join('\n');
+}