@pellux/goodvibes-agent 0.1.1 → 0.1.2

package/CHANGELOG.md

@@ -2,6 +2,14 @@
 
 All notable changes to GoodVibes Agent will be recorded here.
 
+## 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/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.2` is the current installable public alpha of the personal operator assistant built on the GoodVibes TUI foundation.
 
 ## Requirements
 

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.2` is the current installable public alpha release.
 
 ## Package Identity
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "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",

package/src/cli/agent-knowledge-command.ts

@@ -0,0 +1,525 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createBrowserAgentSdk } from '@pellux/goodvibes-sdk/browser/agent';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import type { CliCommandOutput } from './types.ts';
+import type { CliCommandRuntime } from './management.ts';
+import { formatJsonOrText, yesNo } from './management.ts';
+
+type JsonRecord = Record<string, unknown>;
+
+interface AgentDaemonConnection {
+  readonly baseUrl: string;
+  readonly token: string | null;
+  readonly tokenPath: string;
+}
+
+interface AgentKnowledgeFailure {
+  readonly ok: false;
+  readonly kind: 'daemon_unavailable' | 'auth_required' | 'daemon_route_unavailable' | 'daemon_error';
+  readonly error: string;
+  readonly baseUrl: string;
+  readonly route: string;
+}
+
+interface AgentKnowledgeSuccess<TData> {
+  readonly ok: true;
+  readonly kind: string;
+  readonly route: string;
+  readonly data: TData;
+}
+
+type AgentKnowledgeResult<TData> = AgentKnowledgeSuccess<TData> | AgentKnowledgeFailure;
+
+function isRecord(value: unknown): value is JsonRecord {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+
+function readString(record: JsonRecord | null, key: string): string | null {
+  const value = record?.[key];
+  return typeof value === 'string' ? value : null;
+}
+
+function readNumber(record: JsonRecord | null, key: string): number | null {
+  const value = record?.[key];
+  return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+
+function readBoolean(record: JsonRecord | null, key: string): boolean | null {
+  const value = record?.[key];
+  return typeof value === 'boolean' ? value : null;
+}
+
+function readArray(record: JsonRecord | null, key: string): readonly unknown[] {
+  const value = record?.[key];
+  return Array.isArray(value) ? value : [];
+}
+
+function cleanInline(value: unknown): string {
+  return typeof value === 'string' ? value.replace(/\s+/g, ' ').trim() : '';
+}
+
+function commandValues(args: readonly string[]): string[] {
+  const values: string[] = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index]!;
+    if (!token.startsWith('--')) {
+      values.push(token);
+      continue;
+    }
+    if (!token.includes('=') && args[index + 1] && !args[index + 1]!.startsWith('--')) index += 1;
+  }
+  return values;
+}
+
+function delegationTaskValues(args: readonly string[]): string[] {
+  const values: string[] = [];
+  for (const token of args) {
+    if (token === '--wrfc') continue;
+    if (!token.startsWith('--')) values.push(token);
+  }
+  return values;
+}
+
+function readOptionValue(args: readonly string[], name: string): string | undefined {
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index]!;
+    if (token === name) {
+      const next = args[index + 1];
+      return next && !next.startsWith('--') ? next : undefined;
+    }
+    if (token.startsWith(`${name}=`)) return token.slice(name.length + 1);
+  }
+  return undefined;
+}
+
+function readPositiveInt(args: readonly string[], name: string, fallback: number): number {
+  const raw = readOptionValue(args, name);
+  if (!raw) return fallback;
+  const parsed = Number.parseInt(raw, 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+
+function readStringList(args: readonly string[], name: string): readonly string[] {
+  const raw = readOptionValue(args, name);
+  if (!raw) return [];
+  return raw.split(',').map((entry) => entry.trim()).filter(Boolean);
+}
+
+function hasFlag(args: readonly string[], flag: string): boolean {
+  return args.includes(flag);
+}
+
+function packageJsonPath(): string {
+  return join(dirname(fileURLToPath(import.meta.url)), '..', '..', 'package.json');
+}
+
+function readPackageMetadata(): { readonly version: string; readonly sdkVersion: string } {
+  try {
+    const parsed = JSON.parse(readFileSync(packageJsonPath(), 'utf-8')) as unknown;
+    if (!isRecord(parsed)) return { version: 'unknown', sdkVersion: 'unknown' };
+    const dependencies = isRecord(parsed.dependencies) ? parsed.dependencies : {};
+    return {
+      version: typeof parsed.version === 'string' ? parsed.version : 'unknown',
+      sdkVersion: typeof dependencies['@pellux/goodvibes-sdk'] === 'string'
+        ? dependencies['@pellux/goodvibes-sdk']
+        : 'unknown',
+    };
+  } catch {
+    return { version: 'unknown', sdkVersion: 'unknown' };
+  }
+}
+
+function resolveDaemonConnection(runtime: CliCommandRuntime): AgentDaemonConnection {
+  const host = String(runtime.configManager.get('controlPlane.host') ?? '127.0.0.1');
+  const port = Number(runtime.configManager.get('controlPlane.port') ?? 3421);
+  const baseUrl = `http://${host}:${Number.isFinite(port) ? port : 3421}`;
+  const tokenPath = join(runtime.homeDirectory, '.goodvibes', 'daemon', 'operator-tokens.json');
+  if (!existsSync(tokenPath)) return { baseUrl, token: null, tokenPath };
+  try {
+    const parsed = JSON.parse(readFileSync(tokenPath, 'utf-8')) as unknown;
+    const token = isRecord(parsed) && typeof parsed.token === 'string' ? parsed.token : null;
+    return { baseUrl, token, tokenPath };
+  } catch {
+    return { baseUrl, token: null, tokenPath };
+  }
+}
+
+async function fetchDaemonStatus(connection: AgentDaemonConnection): Promise<{ readonly ok: boolean; readonly status: number; readonly body: unknown }> {
+  try {
+    const response = await fetch(`${connection.baseUrl}/status`, {
+      headers: connection.token ? { authorization: `Bearer ${connection.token}` } : undefined,
+    });
+    const text = await response.text();
+    let body: unknown = text;
+    try {
+      body = JSON.parse(text) as unknown;
+    } catch {
+      body = text;
+    }
+    return { ok: response.ok, status: response.status, body };
+  } catch (error) {
+    return { ok: false, status: 0, body: summarizeError(error) };
+  }
+}
+
+function classifyKnowledgeError(error: unknown, connection: AgentDaemonConnection, route: string): AgentKnowledgeFailure {
+  const message = summarizeError(error);
+  const lower = message.toLowerCase();
+  if (lower.includes('401') || lower.includes('unauthorized') || lower.includes('auth')) {
+    return { ok: false, kind: 'auth_required', error: message, baseUrl: connection.baseUrl, route };
+  }
+  if (lower.includes('404') || lower.includes('not found')) {
+    return { ok: false, kind: 'daemon_route_unavailable', error: message, baseUrl: connection.baseUrl, route };
+  }
+  if (lower.includes('fetch') || lower.includes('connect') || lower.includes('econnrefused')) {
+    return { ok: false, kind: 'daemon_unavailable', error: message, baseUrl: connection.baseUrl, route };
+  }
+  return { ok: false, kind: 'daemon_error', error: message, baseUrl: connection.baseUrl, route };
+}
+
+function createAgentSdk(connection: AgentDaemonConnection) {
+  return createBrowserAgentSdk({
+    baseUrl: connection.baseUrl,
+    authToken: connection.token,
+  });
+}
+
+function sourceLine(value: unknown): string {
+  const record = isRecord(value) ? value : {};
+  const title = cleanInline(record.title)
+    || cleanInline(record.canonicalUri)
+    || cleanInline(record.sourceUri)
+    || cleanInline(record.url)
+    || cleanInline(record.id)
+    || 'untitled';
+  const type = cleanInline(record.sourceType) || cleanInline(record.type) || 'source';
+  const url = cleanInline(record.canonicalUri) || cleanInline(record.sourceUri) || cleanInline(record.url);
+  return url && url !== title ? `[${type}] ${title} (${url})` : `[${type}] ${title}`;
+}
+
+function resultLine(value: unknown): string {
+  const record = isRecord(value) ? value : {};
+  const title = cleanInline(record.title) || cleanInline(record.id) || 'untitled';
+  const id = cleanInline(record.id);
+  const type = cleanInline(record.type) || cleanInline(record.kind) || cleanInline(record.sourceType) || 'result';
+  const score = readNumber(record, 'score');
+  const url = cleanInline(record.url) || cleanInline(record.canonicalUri) || cleanInline(record.sourceUri);
+  const snippet = cleanInline(record.snippet) || cleanInline(record.summary) || cleanInline(record.text);
+  const parts = [
+    `[${type}] ${title}`,
+    id && id !== title ? `id=${id}` : '',
+    score !== null ? `score=${score.toFixed(3)}` : '',
+    url ? `url=${url}` : '',
+  ].filter((part) => part.length > 0);
+  return snippet ? `${parts.join('  ')}\n    ${snippet}` : parts.join('  ');
+}
+
+function formatStatus(data: unknown): string {
+  const record = isRecord(data) ? data : {};
+  const ready = readBoolean(record, 'ready');
+  const sourceCount = readNumber(record, 'sourceCount');
+  const nodeCount = readNumber(record, 'nodeCount');
+  const issueCount = readNumber(record, 'issueCount');
+  const edgeCount = readNumber(record, 'edgeCount');
+  const storagePath = readString(record, 'storagePath');
+  return [
+    'Agent Knowledge status',
+    `  ready: ${ready === null ? 'unknown' : yesNo(ready)}`,
+    `  sources: ${sourceCount ?? 'unknown'}`,
+    `  nodes: ${nodeCount ?? 'unknown'}`,
+    `  edges: ${edgeCount ?? 'unknown'}`,
+    `  issues: ${issueCount ?? 'unknown'}`,
+    storagePath ? `  storage: ${storagePath}` : null,
+    '  route: /api/goodvibes-agent/knowledge/status',
+  ].filter((line): line is string => Boolean(line)).join('\n');
+}
+
+function formatAsk(data: unknown, query: string): string {
+  const record = isRecord(data) ? data : {};
+  const answer = isRecord(record.answer) ? record.answer : record;
+  const text = cleanInline(answer.text) || cleanInline(record.answer) || 'No answer returned.';
+  const confidence = readNumber(answer, 'confidence') ?? readNumber(record, 'confidence');
+  const synthesized = readBoolean(answer, 'synthesized');
+  const sources = readArray(answer, 'sources');
+  const facts = readArray(answer, 'facts');
+  const gaps = readArray(answer, 'gaps');
+  const lines = [
+    `Agent Knowledge answer: ${query}`,
+    text,
+    '',
+    `confidence: ${confidence ?? 'unknown'}${synthesized === null ? '' : `  synthesized: ${yesNo(synthesized)}`}`,
+  ];
+  if (sources.length > 0) {
+    lines.push('', 'Sources:', ...sources.slice(0, 8).map((source) => `  - ${sourceLine(source)}`));
+  }
+  if (facts.length > 0) lines.push('', `Facts: ${facts.length}`);
+  if (gaps.length > 0) lines.push('', `Gaps: ${gaps.length}`);
+  return lines.join('\n');
+}
+
+function formatSearch(data: unknown, query: string): string {
+  const record = isRecord(data) ? data : {};
+  const items = readArray(record, 'items');
+  const results = items.length > 0 ? items : readArray(record, 'results');
+  if (results.length === 0) {
+    return [
+      `Agent Knowledge search: ${query}`,
+      '  no results',
+      '  route: /api/goodvibes-agent/knowledge/search',
+    ].join('\n');
+  }
+  return [
+    `Agent Knowledge search: ${query}`,
+    ...results.slice(0, 10).map((result, index) => `  ${index + 1}. ${resultLine(result)}`),
+  ].join('\n');
+}
+
+function formatIngest(data: unknown, url: string): string {
+  const record = isRecord(data) ? data : {};
+  const source = isRecord(record.source) ? record.source : record;
+  const sourceId = cleanInline(source.id);
+  const canonicalUri = cleanInline(source.canonicalUri) || cleanInline(source.sourceUri) || url;
+  const artifactId = cleanInline(record.artifactId);
+  return [
+    'Agent Knowledge ingest-url accepted',
+    `  source: ${sourceId || '(pending)'}`,
+    `  url: ${canonicalUri}`,
+    artifactId ? `  artifact: ${artifactId}` : null,
+    '  route: /api/goodvibes-agent/knowledge/ingest/url',
+  ].filter((line): line is string => Boolean(line)).join('\n');
+}
+
+function buildDelegationBody(task: string, wrfcRequested: boolean): string {
+  return [
+    'GoodVibes Agent explicit build delegation.',
+    '',
+    'Original user ask:',
+    task,
+    '',
+    'Agent policy:',
+    '- GoodVibes Agent is not the coding TUI.',
+    '- Preserve the full original ask.',
+    '- GoodVibes TUI owns file edits, git/worktree flows, sandbox/QEMU UX, and any WRFC owner chain.',
+    wrfcRequested
+      ? '- WRFC was explicitly requested by the Agent user for this build/fix/review delegation.'
+      : '- WRFC was not explicitly requested; do not turn this into WRFC solely because it came from Agent.',
+  ].join('\n');
+}
+
+function formatFailure(failure: AgentKnowledgeFailure, json: boolean): string {
+  if (json) return JSON.stringify(failure, null, 2);
+  return [
+    `Agent Knowledge error: ${failure.kind}`,
+    `  ${failure.error}`,
+    `  daemon: ${failure.baseUrl}`,
+    `  route: ${failure.route}`,
+    failure.kind === 'daemon_route_unavailable'
+      ? '  next: update/restart the external GoodVibes daemon to the SDK version required by this Agent package.'
+      : null,
+  ].filter((line): line is string => Boolean(line)).join('\n');
+}
+
+async function runKnowledgeCall<TData>(
+  runtime: CliCommandRuntime,
+  route: string,
+  call: (connection: AgentDaemonConnection) => Promise<TData>,
+): Promise<AgentKnowledgeResult<TData>> {
+  const connection = resolveDaemonConnection(runtime);
+  if (!connection.token) {
+    return {
+      ok: false,
+      kind: 'auth_required',
+      error: `No daemon operator token found at ${connection.tokenPath}`,
+      baseUrl: connection.baseUrl,
+      route,
+    };
+  }
+  try {
+    const data = await call(connection);
+    return { ok: true, kind: route, route, data };
+  } catch (error) {
+    return classifyKnowledgeError(error, connection, route);
+  }
+}
+
+export async function handleAgentKnowledgeCommand(runtime: CliCommandRuntime): Promise<CliCommandOutput> {
+  const [sub = 'status', ...rest] = runtime.cli.commandArgs;
+  const normalized = sub.toLowerCase();
+  const json = runtime.cli.flags.outputFormat === 'json';
+
+  if (normalized === 'status') {
+    const result = await runKnowledgeCall(runtime, 'knowledge.status', async (connection) => (
+      await createAgentSdk(connection).knowledge.status()
+    ));
+    if (!result.ok) return { output: formatFailure(result, json), exitCode: 1 };
+    return {
+      output: formatJsonOrText(runtime.cli)(result, formatStatus(result.data)),
+      exitCode: 0,
+    };
+  }
+
+  if (normalized === 'ask') {
+    const query = commandValues(rest).join(' ').trim();
+    if (!query) return { output: 'Usage: goodvibes-agent knowledge ask <question> [--limit <n>] [--mode concise|standard|detailed]', exitCode: 2 };
+    const mode = readOptionValue(rest, '--mode');
+    const selectedMode = mode === 'concise' || mode === 'standard' || mode === 'detailed' ? mode : 'standard';
+    const limit = readPositiveInt(rest, '--limit', 8);
+    const result = await runKnowledgeCall(runtime, 'knowledge.ask', async (connection) => (
+      await createAgentSdk(connection).knowledge.ask({
+        query,
+        limit,
+        mode: selectedMode,
+        includeSources: true,
+        includeConfidence: true,
+        includeLinkedObjects: true,
+      })
+    ));
+    if (!result.ok) return { output: formatFailure(result, json), exitCode: 1 };
+    return {
+      output: formatJsonOrText(runtime.cli)(result, formatAsk(result.data, query)),
+      exitCode: 0,
+    };
+  }
+
+  if (normalized === 'search') {
+    const query = commandValues(rest).join(' ').trim();
+    if (!query) return { output: 'Usage: goodvibes-agent knowledge search <query> [--limit <n>]', exitCode: 2 };
+    const limit = readPositiveInt(rest, '--limit', 10);
+    const result = await runKnowledgeCall(runtime, 'knowledge.search', async (connection) => (
+      await createAgentSdk(connection).knowledge.search({ query, limit })
+    ));
+    if (!result.ok) return { output: formatFailure(result, json), exitCode: 1 };
+    return {
+      output: formatJsonOrText(runtime.cli)(result, formatSearch(result.data, query)),
+      exitCode: 0,
+    };
+  }
+
+  if (normalized === 'ingest-url') {
+    const values = commandValues(rest);
+    const url = values[0];
+    if (!url) return { output: 'Usage: goodvibes-agent knowledge ingest-url <url> [--title <title>] [--tags a,b]', exitCode: 2 };
+    const title = readOptionValue(rest, '--title');
+    const tags = readStringList(rest, '--tags');
+    const result = await runKnowledgeCall(runtime, 'knowledge.ingest.url', async (connection) => (
+      await createAgentSdk(connection).operator.invoke('knowledge.ingest.url', {
+        url,
+        title,
+        tags,
+        sourceType: 'url',
+        connectorId: 'goodvibes-agent-cli',
+      })
+    ));
+    if (!result.ok) return { output: formatFailure(result, json), exitCode: 1 };
+    return {
+      output: formatJsonOrText(runtime.cli)(result, formatIngest(result.data, url)),
+      exitCode: 0,
+    };
+  }
+
+  return {
+    output: 'Usage: goodvibes-agent knowledge [status|ask <question>|search <query>|ingest-url <url>]',
+    exitCode: 2,
+  };
+}
+
+export async function handleCompatCommand(runtime: CliCommandRuntime): Promise<CliCommandOutput> {
+  const connection = resolveDaemonConnection(runtime);
+  const metadata = readPackageMetadata();
+  const daemon = await fetchDaemonStatus(connection);
+  const daemonRecord = isRecord(daemon.body) ? daemon.body : {};
+  const daemonVersion = readString(daemonRecord, 'version') ?? 'unknown';
+  const versionCompatible = daemon.ok && daemonVersion === metadata.sdkVersion;
+  const knowledgeRoute = await runKnowledgeCall(runtime, 'knowledge.status', async (routeConnection) => (
+    await createAgentSdk(routeConnection).knowledge.status()
+  ));
+  const knowledgeRouteReady = knowledgeRoute.ok;
+  const value = {
+    ok: versionCompatible && knowledgeRouteReady,
+    packageVersion: metadata.version,
+    sdkPin: metadata.sdkVersion,
+    daemon: {
+      baseUrl: connection.baseUrl,
+      status: daemon.status,
+      version: daemonVersion,
+      reachable: daemon.ok,
+      compatible: versionCompatible,
+    },
+    auth: {
+      tokenPresent: Boolean(connection.token),
+      tokenPath: connection.tokenPath,
+    },
+    agentKnowledge: {
+      route: '/api/goodvibes-agent/knowledge/status',
+      ready: knowledgeRouteReady,
+      kind: knowledgeRoute.ok ? 'ok' : knowledgeRoute.kind,
+    },
+  };
+  const text = [
+    'GoodVibes Agent compatibility',
+    `  package: ${metadata.version}`,
+    `  SDK pin: ${metadata.sdkVersion}`,
+    `  daemon: ${daemonVersion} at ${connection.baseUrl} (${daemon.ok ? 'reachable' : 'unreachable'})`,
+    `  version compatible: ${yesNo(versionCompatible)}`,
+    `  operator token: ${connection.token ? 'present' : 'missing'} (${connection.tokenPath})`,
+    `  Agent knowledge route: ${knowledgeRouteReady ? 'ready' : `not ready (${knowledgeRoute.ok ? 'unknown' : knowledgeRoute.kind})`}`,
+    ...(versionCompatible ? [] : ['  next: update/restart the external GoodVibes daemon so /status matches the Agent SDK pin.']),
+  ].join('\n');
+  return {
+    output: runtime.cli.flags.outputFormat === 'json' ? JSON.stringify(value, null, 2) : text,
+    exitCode: value.ok ? 0 : 1,
+  };
+}
+
+export async function handleDelegateCommand(runtime: CliCommandRuntime): Promise<CliCommandOutput> {
+  const wrfcRequested = hasFlag(runtime.cli.commandArgs, '--wrfc');
+  const task = delegationTaskValues(runtime.cli.commandArgs).join(' ').trim();
+  if (!task) {
+    return {
+      output: 'Usage: goodvibes-agent delegate [--wrfc] <build/fix/review task>',
+      exitCode: 2,
+    };
+  }
+  const result = await runKnowledgeCall(runtime, 'sessions.messages.create', async (connection) => {
+    const sdk = createAgentSdk(connection);
+    const created = await sdk.operator.invoke('sessions.create', {
+      title: `Agent delegation: ${task.slice(0, 72)}`,
+      surfaceKind: 'goodvibes-agent',
+      surfaceId: 'goodvibes-agent-cli',
+    });
+    const sessionId = isRecord(created.session) && typeof created.session.id === 'string'
+      ? created.session.id
+      : null;
+    if (!sessionId) throw new Error('sessions.create returned no session id.');
+    const message = await sdk.operator.invoke('sessions.messages.create', {
+      sessionId,
+      body: buildDelegationBody(task, wrfcRequested),
+      surfaceKind: 'goodvibes-agent',
+      surfaceId: 'goodvibes-agent-cli',
+      kind: 'task',
+      routing: {
+        executionIntent: {
+          riskClass: 'elevated',
+          requiresApproval: true,
+          networkPolicy: 'inherit',
+          filesystemPolicy: 'workspace-write',
+        },
+      },
+    });
+    return { sessionId, message, task, wrfcRequested };
+  });
+  if (!result.ok) return { output: formatFailure(result, runtime.cli.flags.outputFormat === 'json'), exitCode: 1 };
+  const text = [
+    'Delegation submitted to GoodVibes TUI/shared-session routes.',
+    `  session: ${result.data.sessionId}`,
+    `  mode: ${result.data.wrfcRequested ? 'WRFC requested' : 'direct build delegation'}`,
+    `  task: ${result.data.task}`,
+    '  next: check GoodVibes TUI shared-session/task status for the result.',
+  ].join('\n');
+  return {
+    output: formatJsonOrText(runtime.cli)(result, text),
+    exitCode: 0,
+  };
+}

package/src/cli/help.ts

@@ -39,6 +39,9 @@ export function renderGoodVibesHelp(binary = 'goodvibes-agent'): string {
     '  models [provider]          List/use/pin selectable models and recent model history',
     '  providers                  List/inspect/use provider config/auth posture',
     '  auth                       Inspect and manage local users, sessions, and bootstrap auth',
+    '  compat                     Inspect Agent SDK pin, daemon version, and Agent knowledge route readiness',
+    '  knowledge                  Use isolated Agent Knowledge/Wiki routes',
+    '  delegate                   Explicitly delegate build/fix/review work to GoodVibes TUI',
     '  subscription               Start/finish/logout provider subscription sessions',
     '  secrets                    List, set, link, delete, and test GoodVibes secret refs',
     '  sessions                   List, show, export, or resume saved sessions',
@@ -89,6 +92,10 @@ export function renderGoodVibesHelp(binary = 'goodvibes-agent'): string {
     `  ${binary} models current`,
     `  ${binary} models use openai:gpt-5.2`,
     `  ${binary} providers inspect openai`,
+    `  ${binary} compat`,
+    `  ${binary} knowledge status`,
+    `  ${binary} knowledge ask "What is GoodVibes Agent?"`,
+    `  ${binary} delegate --wrfc "fix the failing tests in ~/work/project"`,
     `  ${binary} surfaces`,
     `  ${binary} surfaces check`,
     `  ${binary} service check`,
@@ -147,6 +154,34 @@ const COMMAND_HELP: Record<string, CommandHelp> = {
     summary: 'Inspect and manage local admin users, bootstrap auth, and local sessions.',
     examples: ['auth', 'auth add-user admin --password-stdin', 'auth clear-bootstrap'],
   },
+  compat: {
+    usage: ['compat', 'compat --json'],
+    summary: 'Inspect package SDK pin, live daemon version, and Agent-specific knowledge route readiness.',
+    examples: ['compat', 'compat --json'],
+  },
+  knowledge: {
+    usage: [
+      'knowledge status',
+      'knowledge ask <question> [--limit <n>] [--mode concise|standard|detailed]',
+      'knowledge search <query> [--limit <n>]',
+      'knowledge ingest-url <url> [--title <title>] [--tags a,b]',
+    ],
+    summary: 'Call isolated Agent Knowledge/Wiki routes under /api/goodvibes-agent/knowledge. No default wiki or HomeGraph fallback.',
+    examples: [
+      'knowledge status',
+      'knowledge ask "What is GoodVibes Agent?"',
+      'knowledge search "release checklist"',
+      'knowledge ingest-url https://example.com/page --title "Reference"',
+    ],
+  },
+  delegate: {
+    usage: ['delegate [--wrfc] <build/fix/review task>'],
+    summary: 'Create one shared-session task request for GoodVibes TUI. WRFC is requested only with --wrfc.',
+    examples: [
+      'delegate "fix the failing tests in this repo"',
+      'delegate --wrfc "implement the settings screen and review it"',
+    ],
+  },
   subscription: {
     usage: ['subscription list', 'subscription providers', 'subscription inspect <provider>', 'subscription login <provider> start|finish', 'subscription logout <provider>'],
     summary: 'Manage OAuth/subscription-backed provider sessions such as OpenAI subscription access.',

package/src/cli/management.ts

@@ -21,6 +21,7 @@ import { beginOpenAICodexLogin, exchangeOpenAICodexCode } from '@pellux/goodvibe
 import { inspectProviderAuth } from '@/runtime/index.ts';
 import { getOrCreateCompanionToken, buildCompanionConnectionInfo, encodeConnectionPayload, formatConnectionBlock } from '@pellux/goodvibes-sdk/platform/pairing';
 import { generateQrMatrix, renderQrToString } from '@pellux/goodvibes-sdk/platform/pairing';
+import { UserAuthManager } from '@pellux/goodvibes-sdk/platform/security';
 import type { GoodVibesCliParseResult } from './types.ts';
 import { formatProviderAuthRoute, summarizeProviderAuthRoutes } from './provider-auth-routes.ts';
 import { classifyProviderSetup } from './provider-classification.ts';
@@ -31,6 +32,7 @@ import { handleServiceCommand } from './service-command.ts';
 import { handleBundleCommand } from './bundle-command.ts';
 import { buildListenerTestResult, formatListenerTestResult, handleSurfacesCommand } from './surface-command.ts';
 import { buildControlPlaneStatusResult, formatControlPlaneStatus, handleSecrets, handleSessions, handleTasks, renderPairing, renderRemote, renderSubscriptions, renderWeb } from './management-commands.ts';
+import { handleAgentKnowledgeCommand, handleCompatCommand, handleDelegateCommand } from './agent-knowledge-command.ts';
 import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
 
 export interface CliCommandRuntime {
@@ -289,6 +291,14 @@ export function readAuthPaths(runtime: CliCommandRuntime) {
   };
 }
 
+function createCliLocalUserAuthManager(runtime: CliCommandRuntime): UserAuthManager {
+  const paths = readAuthPaths(runtime);
+  return new UserAuthManager({
+    bootstrapFilePath: paths.userStorePath,
+    bootstrapCredentialPath: paths.bootstrapCredentialPath,
+  });
+}
+
 export async function runNonInteractiveAgent(runtime: CliCommandRuntime): Promise<number> {
   const prompt = runtime.cli.flags.prompt ?? runtime.cli.positionals.join(' ').trim();
   if (!prompt) {
@@ -574,7 +584,7 @@ async function renderModels(runtime: CliCommandRuntime): Promise<string> {
 }
 
 async function renderAuth(runtime: CliCommandRuntime): Promise<string> {
-  return await withRuntimeServices(runtime, (services) => {
+  const localUserAuthManager = createCliLocalUserAuthManager(runtime);
     const [sub = 'status', ...rawRest] = runtime.cli.commandArgs;
     const rest = commandValues(rawRest);
     if (sub === 'add-user' || sub === 'add') {
@@ -583,13 +593,13 @@ async function renderAuth(runtime: CliCommandRuntime): Promise<string> {
       const password = readPassword(rawRest);
       if (!password) return 'Usage: goodvibes auth add-user <username> [--password <value>|--password-stdin] [--role <role>]';
       const roles = readOptionValues(rawRest, '--role').filter((role) => role.length > 0);
-      const user = services.localUserAuthManager.addUser(username, password, roles.length > 0 ? roles : ['user']);
+      const user = localUserAuthManager.addUser(username, password, roles.length > 0 ? roles : ['user']);
       return `Auth user added: ${user.username} (${user.roles.join(', ') || 'no roles'})`;
     }
     if (sub === 'delete-user' || sub === 'remove-user') {
       const username = rest[0];
       if (!username) return 'Usage: goodvibes auth delete-user <username>';
-      return services.localUserAuthManager.deleteUser(username)
+      return localUserAuthManager.deleteUser(username)
         ? `Auth user deleted: ${username}`
         : `No auth user found: ${username}`;
     }
@@ -598,31 +608,31 @@ async function renderAuth(runtime: CliCommandRuntime): Promise<string> {
       if (!username) return 'Usage: goodvibes auth rotate-password <username> [--password <value>|--password-stdin]';
       const password = readPassword(rawRest);
       if (!password) return 'Usage: goodvibes auth rotate-password <username> [--password <value>|--password-stdin]';
-      services.localUserAuthManager.rotatePassword(username, password);
+      localUserAuthManager.rotatePassword(username, password);
       return `Auth password rotated: ${username}`;
     }
     if (sub === 'revoke-session') {
       const token = rest[0];
       if (!token) return 'Usage: goodvibes auth revoke-session <token-or-fingerprint>';
-      return services.localUserAuthManager.revokeSession(token)
+      return localUserAuthManager.revokeSession(token)
         ? 'Auth session revoked.'
         : 'No auth session found.';
     }
     if (sub === 'revoke-sessions') {
       const username = rest[0];
       if (!username) return 'Usage: goodvibes auth revoke-sessions <username>';
-      const count = services.localUserAuthManager.revokeSessionsForUser(username);
+      const count = localUserAuthManager.revokeSessionsForUser(username);
       return `Auth sessions revoked for ${username}: ${count}`;
     }
     if (sub === 'clear-bootstrap') {
-      return services.localUserAuthManager.clearBootstrapCredentialFile()
+      return localUserAuthManager.clearBootstrapCredentialFile()
         ? 'Bootstrap credential file removed.'
         : 'Bootstrap credential file was already absent.';
     }
     if (sub !== 'status' && sub !== 'list' && sub !== 'users' && sub !== 'sessions') {
       return 'Usage: goodvibes auth [status|users|sessions|add-user|delete-user|rotate-password|revoke-session|revoke-sessions|clear-bootstrap]';
     }
-    const snapshot = services.localUserAuthManager.inspect();
+    const snapshot = localUserAuthManager.inspect();
     const paths = readAuthPaths(runtime);
     const value = {
       ...paths,
@@ -652,7 +662,6 @@ async function renderAuth(runtime: CliCommandRuntime): Promise<string> {
       `  bootstrap credential: ${paths.bootstrapCredentialPresent ? 'present' : 'missing'} (${paths.bootstrapCredentialPath})`,
       `  operator tokens: ${paths.operatorTokenPresent ? 'present' : 'missing'} (${paths.operatorTokenPath})`,
     ].join('\n'));
-  });
 }
 
 
@@ -684,6 +693,21 @@ export async function handleGoodVibesCliCommand(runtime: CliCommandRuntime): Pro
         console.log(output);
         return { handled: true, exitCode: exitCodeForText(output) };
       }
+      case 'compat': {
+        const result = await handleCompatCommand(runtime);
+        console.log(result.output);
+        return { handled: true, exitCode: result.exitCode };
+      }
+      case 'knowledge': {
+        const result = await handleAgentKnowledgeCommand(runtime);
+        console.log(result.output);
+        return { handled: true, exitCode: result.exitCode };
+      }
+      case 'delegate': {
+        const result = await handleDelegateCommand(runtime);
+        console.log(result.output);
+        return { handled: true, exitCode: result.exitCode };
+      }
       case 'subscription': {
         const output = await renderSubscriptions(runtime);
         console.log(output);

package/src/cli/parser.ts

@@ -26,6 +26,13 @@ const COMMAND_ALIASES: Readonly<Record<string, GoodVibesCliCommand>> = {
   providers: 'providers',
   provider: 'providers',
   auth: 'auth',
+  compat: 'compat',
+  compatibility: 'compat',
+  knowledge: 'knowledge',
+  know: 'knowledge',
+  kb: 'knowledge',
+  delegate: 'delegate',
+  build: 'delegate',
   subscription: 'subscription',
   subscriptions: 'subscription',
   secrets: 'secrets',

package/src/cli/types.ts

@@ -10,6 +10,9 @@ export type GoodVibesCliCommand =
   | 'models'
   | 'providers'
   | 'auth'
+  | 'compat'
+  | 'knowledge'
+  | 'delegate'
   | 'subscription'
   | 'secrets'
   | 'sessions'

package/src/input/agent-workspace.ts

@@ -203,7 +203,7 @@ export const AGENT_WORKSPACE_CATEGORIES: readonly AgentWorkspaceCategory[] = [
     detail: 'Agent does not become the coding TUI. Build, implement, fix, patch, and review work must be handed to GoodVibes TUI with the full original ask and WRFC only when explicitly requested.',
     actions: [
       { id: 'delegate-guidance', label: 'Delegation rule', detail: 'For build/fix/review work, delegate one request to GoodVibes TUI instead of spawning local Engineer/Reviewer/Tester roots.', kind: 'guidance', safety: 'delegates' },
-      { id: 'review-command', label: 'Review delegation command', detail: 'Use /review or /wrfc only when the user explicitly asks for code review/build execution.', command: '/review', kind: 'command', safety: 'delegates' },
+      { id: 'review-command', label: 'Review delegation command', detail: 'Use /delegate --wrfc only when the user explicitly asks for code review/build execution.', command: '/delegate --wrfc <task>', kind: 'command', safety: 'delegates' },
       { id: 'remote-policy', label: 'Remote runner policy', detail: 'Remote dispatch/rerun is blocked in Agent; TUI owns runner topology for delegated build work.', command: '/remote dispatch', kind: 'command', safety: 'blocked' },
     ],
   },

package/src/input/commands/delegation-runtime.ts

@@ -0,0 +1,129 @@
+import type { CommandContext, CommandRegistry } from '../command-registry.ts';
+import type { SharedSessionParticipant } from '@pellux/goodvibes-sdk/platform/control-plane';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+
+function hasFlag(args: readonly string[], flag: string): boolean {
+  return args.includes(flag);
+}
+
+function delegationTaskValues(args: readonly string[]): string[] {
+  const values: string[] = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const token = args[index]!;
+    if (token === '--wrfc') continue;
+    if (!token.startsWith('--')) {
+      values.push(token);
+      continue;
+    }
+  }
+  return values;
+}
+
+function buildDelegationBody(task: string, wrfcRequested: boolean): string {
+  return [
+    'GoodVibes Agent explicit build delegation.',
+    '',
+    'Original user ask:',
+    task,
+    '',
+    'Agent policy:',
+    '- GoodVibes Agent is not the coding TUI.',
+    '- Preserve the full original ask.',
+    '- GoodVibes TUI owns file edits, git/worktree flows, sandbox/QEMU UX, and any WRFC owner chain.',
+    wrfcRequested
+      ? '- WRFC was explicitly requested by the Agent user for this build/fix/review delegation.'
+      : '- WRFC was not explicitly requested; do not turn this into WRFC solely because it came from Agent.',
+  ].join('\n');
+}
+
+export function registerDelegationRuntimeCommands(registry: CommandRegistry): void {
+  const makeHandler = (defaultWrfc: boolean) => async (args: string[], ctx: CommandContext): Promise<void> => {
+    const wrfcRequested = defaultWrfc || hasFlag(args, '--wrfc');
+    const task = delegationTaskValues(args).join(' ').trim();
+    if (!task) {
+      ctx.print(defaultWrfc ? 'Usage: /wrfc <build/fix/review task>' : 'Usage: /delegate [--wrfc] <build/fix/review task>');
+      return;
+    }
+    const operator = ctx.clients?.operator;
+    if (!operator) {
+      ctx.print([
+        'Delegation unavailable: no operator client is attached.',
+        'Use the external daemon/shared-session route from a configured Agent runtime, or open GoodVibes TUI in the target workspace.',
+      ].join('\n'));
+      return;
+    }
+    try {
+      const participant = {
+        surfaceKind: 'service',
+        surfaceId: 'goodvibes-agent',
+        externalId: ctx.session.runtime.sessionId,
+        displayName: 'GoodVibes Agent',
+        lastSeenAt: Date.now(),
+      } satisfies SharedSessionParticipant;
+      const session = await operator.sessions.ensureSession({
+        title: `Agent delegation: ${task.slice(0, 72)}`,
+        participant,
+        metadata: {
+          originSurface: 'goodvibes-agent',
+          sourceSessionId: ctx.session.runtime.sessionId,
+          task,
+          wrfcRequested,
+        },
+      });
+      await operator.sessions.submitMessage({
+        sessionId: session.id,
+        body: buildDelegationBody(task, wrfcRequested),
+        surfaceKind: participant.surfaceKind,
+        surfaceId: participant.surfaceId,
+        externalId: participant.externalId,
+        displayName: participant.displayName,
+        title: `Agent delegation: ${task.slice(0, 72)}`,
+        metadata: {
+          originSurface: 'goodvibes-agent',
+          sourceSessionId: ctx.session.runtime.sessionId,
+          kind: 'task',
+          task,
+          wrfcRequested,
+        },
+        routing: {
+          executionIntent: {
+            riskClass: 'elevated',
+            requiresApproval: true,
+            networkPolicy: 'inherit',
+            filesystemPolicy: 'workspace-write',
+          },
+        },
+      });
+      ctx.print([
+        'Delegation submitted to GoodVibes TUI/shared-session routes.',
+        `  session: ${session.id}`,
+        `  mode: ${wrfcRequested ? 'WRFC requested' : 'direct build delegation'}`,
+        `  task: ${task}`,
+        '  next: check GoodVibes TUI shared-session/task status for the result.',
+      ].join('\n'));
+    } catch (error) {
+      ctx.print([
+        'Delegation failed.',
+        `  error: ${summarizeError(error)}`,
+        '  fallback: open GoodVibes TUI in the target workspace and paste the original task there.',
+      ].join('\n'));
+    }
+  };
+
+  registry.register({
+    name: 'delegate',
+    aliases: ['build'],
+    description: 'Explicitly delegate build/fix/review work to GoodVibes TUI through shared-session routes',
+    usage: '[--wrfc] <task>',
+    argsHint: '[--wrfc] <task>',
+    handler: makeHandler(false),
+  });
+  registry.register({
+    name: 'wrfc',
+    aliases: ['review'],
+    description: 'Explicitly delegate build/fix/review work to GoodVibes TUI with WRFC requested',
+    usage: '<task>',
+    argsHint: '<task>',
+    handler: makeHandler(true),
+  });
+}

package/src/input/commands/shell-core.ts

@@ -2,7 +2,6 @@ import type { CommandRegistry } from '../command-registry.ts';
 import type { SelectionItem } from '../selection-modal.ts';
 import { EFFORT_DESCRIPTIONS } from '@pellux/goodvibes-sdk/platform/providers';
 import { REASONING_BUDGET_MAP } from '@pellux/goodvibes-sdk/platform/providers';
-import { executeWriteQuit } from './quit-shared.ts';
 import { compactConversation, requireKeybindingsManager, requireProviderApi } from './runtime-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
@@ -159,7 +158,7 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
           { id: '/secrets', label: '/secrets set|link|get|test|list|delete', detail: 'Manage encrypted and provider-backed secrets', category: 'Tools & System' },
           { id: '/help', label: '/help', detail: 'This help', category: 'Tools & System' },
           { id: '/quit', label: '/quit', detail: 'Exit', category: 'Tools & System' },
-          { id: '/wq', label: '/wq', detail: 'Commit all git changes and then exit', category: 'Tools & System' },
+          { id: '/wq', label: '/wq', detail: 'Blocked in Agent; git commit/exit belongs to GoodVibes TUI', category: 'Tools & System' },
         ];
         ctx.openSelection('Help  —  Commands', items, { allowSearch: true }, (result) => {
           if (!result) return;
@@ -173,7 +172,7 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
         });
         return;
       }
-      ctx.print('Use /help to open the help modal. Commands: /agent, /model, /provider, /config, /template, /tools, /paste, /sessions, /bookmarks, /save, /load, /undo, /redo, /retry, /clear, /reset, /compact, /export, /title, /effort, /expand, /collapse, /debug, /quit, /wq');
+      ctx.print('Use /help to open the help modal. Commands: /agent, /model, /provider, /config, /template, /tools, /paste, /sessions, /bookmarks, /save, /load, /undo, /redo, /retry, /clear, /reset, /compact, /export, /title, /effort, /expand, /collapse, /debug, /quit');
     },
   });
 
@@ -225,9 +224,13 @@ export function registerShellCoreCommands(registry: CommandRegistry): void {
   registry.register({
     name: 'wq',
     aliases: [':wq'],
-    description: 'Commit all git changes and then exit',
-    async handler(_args, ctx) {
-      await executeWriteQuit(ctx);
+    description: 'Blocked in Agent; git commit/exit is owned by GoodVibes TUI',
+    handler(_args, ctx) {
+      ctx.print([
+        'Blocked: /wq is not available in GoodVibes Agent.',
+        'Git commit, worktree, and coding-session exit flows belong to GoodVibes TUI.',
+        'No files, commits, or repository state were changed.',
+      ].join('\n'));
     },
   });
 

package/src/input/commands.ts

@@ -54,6 +54,7 @@ import { registerCloudflareRuntimeCommands } from './commands/cloudflare-runtime
 import { registerWorkPlanRuntimeCommands } from './commands/work-plan-runtime.ts';
 import { registerAgentWorkspaceRuntimeCommands } from './commands/agent-workspace-runtime.ts';
 import { registerAgentExternalizedTuiCommands } from './commands/agent-externalized-tui.ts';
+import { registerDelegationRuntimeCommands } from './commands/delegation-runtime.ts';
 
 /**
  * registerBuiltinCommands - Register all built-in slash commands into the registry.
@@ -62,6 +63,7 @@ import { registerAgentExternalizedTuiCommands } from './commands/agent-externali
 export function registerBuiltinCommands(registry: CommandRegistry): void {
   registerShellCoreCommands(registry);
   registerAgentWorkspaceRuntimeCommands(registry);
+  registerDelegationRuntimeCommands(registry);
   registerConfigCommand(registry);
   registerOperatorRuntimeCommands(registry);
   registerIntegrationRuntimeCommands(registry);

package/src/input/submission-router.ts

@@ -8,7 +8,7 @@ export interface SubmissionRouterInput {
 }
 
 const PLAN_COMMANDS = new Set(['plan']);
-const DELEGATION_COMMANDS = new Set(['review', 'wrfc', 'teamwork', 'agents', 'remote']);
+const DELEGATION_COMMANDS = new Set(['delegate', 'build', 'review', 'wrfc', 'teamwork', 'agents', 'remote']);
 const PANEL_COMMANDS = new Set(['panel']);
 const ORCHESTRATION_COMMANDS = new Set([
   'orchestration',

package/src/panels/builtin/agent.ts

@@ -3,7 +3,6 @@ import { AgentLogsPanel } from '../agent-logs-panel.ts';
 import { ContextVisualizerPanel } from '../context-visualizer-panel.ts';
 import { ThinkingPanel } from '../thinking-panel.ts';
 import { ToolInspectorPanel } from '../tool-inspector-panel.ts';
-import { WrfcPanel } from '../wrfc-panel.ts';
 import { SchedulePanel } from '../schedule-panel.ts';
 import { ProjectPlanningPanel } from '../project-planning-panel.ts';
 import { WorkPlanPanel } from '../work-plan-panel.ts';
@@ -67,19 +66,6 @@ export function registerAgentPanels(manager: PanelManager, deps: ResolvedBuiltin
     },
   });
 
-  manager.registerType({
-    id: 'wrfc',
-    name: 'WRFC',
-    icon: 'W',
-    category: 'agent',
-    description: 'WRFC chain view: write, review, fix, and confirm cycle status',
-    preload: true,
-    factory: () => {
-      const ui = requireUiServices(deps);
-      return new WrfcPanel(ui.events.workflows, { controller: ui.agents.wrfcController });
-    },
-  });
-
   manager.registerType({
     id: 'work-plan',
     name: 'Work Plan',

package/src/runtime/bootstrap-shell.ts

@@ -33,6 +33,7 @@ import type { TaskManager } from '@/runtime/index.ts';
 import type { UiRuntimeServices } from './ui-services.ts';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
+import { createKnowledgeApi } from '@pellux/goodvibes-sdk/platform/knowledge';
 
 export interface BootstrapShellState {
   readonly commandRegistry: CommandRegistry;
@@ -208,7 +209,7 @@ export function createBootstrapShell(options: BootstrapShellOptions): BootstrapS
     memoryRegistry: services.memoryRegistry,
     integrationHelpers: services.integrationHelpers,
     automationManager: services.automationManager,
-    knowledgeService: services.knowledgeService,
+    knowledgeService: services.agentKnowledgeService,
     projectPlanningService: services.projectPlanningService,
     projectPlanningProjectId: services.projectPlanningProjectId,
     workPlanStore: services.workPlanStore,
@@ -238,7 +239,7 @@ export function createBootstrapShell(options: BootstrapShellOptions): BootstrapS
     sessionOrchestration: services.sessionOrchestration,
     operatorClient: directTransport.operator,
     peerClient: directTransport.peer,
-    knowledgeApi,
+    knowledgeApi: createKnowledgeApi(services.agentKnowledgeService, { memoryRegistry: services.memoryRegistry }),
     hookApi,
     mcpApi,
     opsApi,

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '0.1.1';
+let _version = '0.1.2';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8'));
   _version = pkg.version ?? _version;

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2026 Michael Davis and GoodVibes contributors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.