@pellux/goodvibes-agent 1.5.6 → 1.5.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "1.5.6",
+  "version": "1.5.7",
   "private": false,
   "description": "GoodVibes personal operator assistant TUI with a proactive Agent product brain, isolated Agent Knowledge, local profiles, routines, skills, personas, and explicit build delegation.",
   "type": "module",

package/src/agent/prompt-context-receipts.ts

@@ -9,7 +9,7 @@ import { AgentPersonaRegistry, buildActivePersonaPrompt } from './persona-regist
 import { buildProjectContextPrompt, discoverProjectContextFiles } from './project-context-files.ts';
 import { AgentRoutineRegistry, buildEnabledRoutinesPrompt, evaluateAgentRoutineReadiness } from './routine-registry.ts';
 import { AgentSkillRegistry, buildEnabledSkillsPrompt, evaluateAgentSkillBundleReadiness, evaluateAgentSkillReadiness } from './skill-registry.ts';
-import { buildVibePrompt, discoverVibeFiles } from './vibe-file.ts';
+import { buildVibeProjectionPrompt, discoverVibeFiles } from './vibe-file.ts';
 
 export type PromptContextReceiptStatus = 'active' | 'attention' | 'empty' | 'unavailable';
 export type PromptContextReceiptSource = 'turn' | 'follow_up' | 'manual';
@@ -140,7 +140,9 @@ function receiptSegment(input: Omit<PromptContextReceiptSegment, 'approxTokens'>
 
 function buildRuntimePromptReceiptSegments(input: RuntimePromptCompositionInput): readonly PromptContextReceiptSegment[] {
   const vibe = discoverVibeFiles(input.shellPaths);
-  const vibePrompt = buildVibePrompt(input.shellPaths) ?? '';
+  // W6-C2 (E6): the VIBE prompt is a PROJECTION of persona/constraint records, not a
+  // re-read of the files (discoverVibeFiles above stays for the file-discovery receipt).
+  const vibePrompt = buildVibeProjectionPrompt(input.memoryRegistry) ?? '';
   const projectContext = discoverProjectContextFiles(input.shellPaths);
   const projectContextPrompt = buildProjectContextPrompt(input.shellPaths) ?? '';
   const memoryRecords = input.memoryRegistry.getAll();
@@ -341,7 +343,7 @@ export function composeRuntimePromptWithReceipt(input: RuntimePromptCompositionI
   const supplement = getTierPromptSupplement(tier);
   const prompt = joinPromptParts(
     input.runtimePrompt,
-    buildVibePrompt(input.shellPaths),
+    buildVibeProjectionPrompt(input.memoryRegistry),
     buildProjectContextPrompt(input.shellPaths),
     input.operatorPolicy,
     buildReviewedMemoryPrompt(input.memoryRegistry, { turnText: input.turnText }),

package/src/agent/vibe-file.ts

@@ -1,4 +1,5 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
 import { dirname, isAbsolute, join, resolve } from 'node:path';
 import type { ShellPathService } from '@/runtime/index.ts';
 import { GOODVIBES_AGENT_SURFACE_ROOT } from '../config/surface.ts';
@@ -9,7 +10,7 @@ import { parseMarkdownFrontmatter, stripMarkdownFrontmatter } from './markdown-f
 // the same '## VIBE.md' block from those records (caveat preserved); the file is
 // demoted to an import/export FORMAT folded in via vibeBodyToConstraintOptions.
 import { renderVibeProjection, vibeBodyToConstraintOptions } from '@pellux/goodvibes-sdk/platform/state';
-import type { MemoryRegistry, MemoryScope } from '@pellux/goodvibes-sdk/platform/state';
+import type { MemoryRecord, MemoryRegistry, MemoryScope } from '@pellux/goodvibes-sdk/platform/state';
 
 export type AgentVibeScope = 'project' | 'global';
 
@@ -220,8 +221,8 @@ export function buildVibePrompt(shellPaths: AgentVibePaths): string | null {
  * store, so persona instructions have a single source of truth alongside every other
  * durable fact. Returns null when there are no persona records to project.
  */
-export function buildVibeProjectionPrompt(memoryRegistry: MemoryRegistry): string | null {
-  return renderVibeProjection(memoryRegistry.getAll());
+export function buildVibeProjectionPrompt(memoryRecords: { getAll(): readonly MemoryRecord[] }): string | null {
+  return renderVibeProjection(memoryRecords.getAll());
 }
 
 /**
@@ -255,6 +256,86 @@ export async function importVibeFilesIntoMemory(
   return created;
 }
 
+/**
+ * W6-C2 (E6): the persisted marker that makes the VIBE.md → memory import a strictly
+ * ONE-TIME migration. Keyed by absolute file path → content hash, so importing the same
+ * VIBE.md twice is a no-op (re-import would create near-duplicate persona records), while
+ * a NEW project's VIBE.md still migrates exactly once. Mirrors the sessions.spine-folded
+ * marker precedent (bootstrap.ts) — a small JSON sidecar, read before and written after.
+ */
+interface VibeImportMarker {
+  readonly migrated: Record<string, string>;
+}
+
+function vibeImportMarkerPath(shellPaths: Pick<ShellPathService, 'resolveUserPath'>): string {
+  return shellPaths.resolveUserPath(GOODVIBES_AGENT_SURFACE_ROOT, 'vibe-import.migrated.json');
+}
+
+function readVibeImportMarker(path: string): VibeImportMarker {
+  if (!existsSync(path)) return { migrated: {} };
+  try {
+    const parsed = JSON.parse(readFileSync(path, 'utf-8')) as unknown;
+    const migrated = (parsed as { migrated?: unknown })?.migrated;
+    if (migrated && typeof migrated === 'object' && !Array.isArray(migrated)) {
+      const out: Record<string, string> = {};
+      for (const [key, value] of Object.entries(migrated as Record<string, unknown>)) {
+        if (typeof value === 'string') out[key] = value;
+      }
+      return { migrated: out };
+    }
+  } catch {
+    // Corrupt marker → treat as "nothing migrated"; the path+hash guard still prevents
+    // duplicating any record that was already imported in a prior clean run.
+  }
+  return { migrated: {} };
+}
+
+function writeVibeImportMarker(path: string, marker: VibeImportMarker): void {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(marker, null, 2)}\n`, 'utf-8');
+}
+
+function hashVibeBody(body: string): string {
+  return createHash('sha256').update(body, 'utf-8').digest('hex');
+}
+
+/**
+ * W6-C2 (E6): fold discovered VIBE.md files into persona/constraint records ONCE.
+ * Guarded by a persisted path→hash marker so it never re-imports the same file (which
+ * would create near-duplicate persona records). Called at boot AFTER memoryStore.init().
+ * Returns the number of records created this run (0 when everything is already migrated).
+ */
+export async function importVibeFilesIntoMemoryOnce(
+  memoryRegistry: MemoryRegistry,
+  shellPaths: AgentVibePaths,
+): Promise<number> {
+  const markerPath = vibeImportMarkerPath(shellPaths);
+  const marker = readVibeImportMarker(markerPath);
+  const snapshot = discoverVibeFiles(shellPaths);
+  let created = 0;
+  let changed = false;
+  for (const file of snapshot.files) {
+    const key = resolve(file.path);
+    const hash = hashVibeBody(file.body);
+    if (marker.migrated[key] === hash) continue; // already migrated this exact content
+    const scope: MemoryScope = file.scope === 'global' ? 'team' : 'project';
+    const name = file.frontmatter.name?.trim();
+    const options = vibeBodyToConstraintOptions(file.body, {
+      scope,
+      ...(name ? { name } : {}),
+      sourceRef: file.path,
+    });
+    for (const opts of options) {
+      await memoryRegistry.add(opts);
+      created += 1;
+    }
+    marker.migrated[key] = hash;
+    changed = true;
+  }
+  if (changed) writeVibeImportMarker(markerPath, marker);
+  return created;
+}
+
 export function formatVibeStatus(snapshot: AgentVibeSnapshot): string {
   const lines: string[] = [
     'GoodVibes Agent VIBE.md',

package/src/config/credential-status.ts

@@ -0,0 +1,165 @@
+/**
+ * credential-status.ts — client-side, secret-FREE credential STATUS read.
+ *
+ * W6-C1 (E7 config sharing). When GoodVibes Agent acts as a CLIENT of an adopted
+ * external daemon, it reads credential *status* (configured / usable) from the
+ * daemon's shared store over the wire — the `credentials.get` operator method
+ * (GET /config/credentials, admin + read:config). It NEVER receives raw secret
+ * bytes: the wire contract (CREDENTIALS_SNAPSHOT_SCHEMA) carries status metadata
+ * only. This is a VISIBILITY path, not secret transport.
+ *
+ * Host-vs-client (see the SDK decision record 2026-07-06-config-sharing): a surface
+ * that IS the daemon host reads its own local SecretsManager directly (no wire hop —
+ * src/config/secrets.ts). A surface acting as a daemon client reads STATUS here.
+ * Secret RESOLUTION (the value provider auth needs) always stays local/env; only the
+ * status read moves to the daemon path.
+ *
+ * The degrade contract mirrors goodvibes-webui v1.0.1 `deriveCredentialAvailability`
+ * exactly: a 503 CREDENTIAL_STORE_UNAVAILABLE (by machine code), a METHOD_NOT_FOUND
+ * from an older daemon, or any transport failure yields an honest reason-carrying
+ * `available: false` — NEVER a fabricated "configured", NEVER a surfaced secret byte.
+ */
+
+/** One credential's status metadata from the daemon's shared store — never bytes. */
+export interface CredentialStatusEntry {
+  readonly key: string;
+  readonly configured: boolean;
+  readonly usable: boolean;
+  readonly source?: string;
+  readonly scope?: string;
+  readonly secure?: boolean;
+  readonly overriddenByEnv?: boolean;
+  readonly refSource?: string;
+}
+
+export type CredentialAvailability =
+  | { readonly available: true; readonly credentials: readonly CredentialStatusEntry[] }
+  | { readonly available: false; readonly reason: string };
+
+/** Minimal connection shape for the daemon-client status read. */
+export interface CredentialStatusConnection {
+  readonly baseUrl: string;
+  readonly token: string | null;
+}
+
+type FetchLike = (input: string, init?: RequestInit) => Promise<Response>;
+
+const CREDENTIALS_ROUTE = '/config/credentials';
+const CREDENTIAL_STATUS_TIMEOUT_MS = 1500;
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  return value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : null;
+}
+
+function firstString(record: Record<string, unknown>, keys: readonly string[]): string {
+  for (const key of keys) {
+    const item = record[key];
+    if (typeof item === 'string' && item.trim()) return item;
+  }
+  return '';
+}
+
+/**
+ * Fold a `credentials.get` outcome into an honest availability value. Pure — this is
+ * the exact degrade contract mirrored from webui v1.0.1: keyed on the MACHINE CODE, it
+ * never fabricates "configured" and never carries a secret value. A malformed body (no
+ * credentials array) is treated as unavailable, not silently empty-but-configured.
+ */
+export function deriveCredentialAvailability(
+  outcome: { ok: true; value: unknown } | { ok: false; error: unknown },
+): CredentialAvailability {
+  if (!outcome.ok) {
+    const err = asRecord(outcome.error);
+    const code = err ? firstString(err, ['code']) : '';
+    if (code === 'CREDENTIAL_STORE_UNAVAILABLE') {
+      return { available: false, reason: 'The daemon has no shared credential store wired.' };
+    }
+    if (code === 'METHOD_NOT_FOUND' || code === 'NOT_INVOKABLE') {
+      return { available: false, reason: 'This daemon does not serve credential status yet.' };
+    }
+    return { available: false, reason: 'Credential status unavailable right now.' };
+  }
+  const value = asRecord(outcome.value);
+  const raw = value?.credentials;
+  if (!Array.isArray(raw)) return { available: false, reason: 'Credential status unavailable right now.' };
+  const credentials: CredentialStatusEntry[] = [];
+  for (const item of raw) {
+    const rec = asRecord(item);
+    const key = rec ? firstString(rec, ['key']) : '';
+    if (!rec || !key) continue;
+    credentials.push({
+      key,
+      configured: rec.configured === true,
+      usable: rec.usable === true,
+      source: firstString(rec, ['source']) || undefined,
+      scope: firstString(rec, ['scope']) || undefined,
+      secure: rec.secure === true ? true : rec.secure === false ? false : undefined,
+      overriddenByEnv: rec.overriddenByEnv === true ? true : rec.overriddenByEnv === false ? false : undefined,
+      refSource: firstString(rec, ['refSource']) || undefined,
+    });
+  }
+  return { available: true, credentials };
+}
+
+/**
+ * Extract the machine code from a non-2xx daemon response body, falling back to the
+ * HTTP status for legacy daemons that predate the code field. A 404 with no code is
+ * treated as METHOD_NOT_FOUND (older daemon without the route — same as webui's
+ * isMethodUnavailableError); a 503 with no code as CREDENTIAL_STORE_UNAVAILABLE.
+ */
+function machineCodeFromResponse(body: unknown, status: number): string {
+  const record = asRecord(body);
+  const direct = record ? firstString(record, ['code']) : '';
+  if (direct) return direct;
+  const nested = record ? asRecord(record.error) : null;
+  const nestedCode = nested ? firstString(nested, ['code']) : '';
+  if (nestedCode) return nestedCode;
+  if (status === 404) return 'METHOD_NOT_FOUND';
+  if (status === 503) return 'CREDENTIAL_STORE_UNAVAILABLE';
+  return '';
+}
+
+/**
+ * Read credential status from the connected daemon as a client, honestly degraded.
+ * Status only — the response is folded through {@link deriveCredentialAvailability},
+ * so a down store, an older daemon, an absent token, or a transport failure all become
+ * a reason-carrying `available: false`, never a fabricated "configured" and never a
+ * secret byte. `key` narrows to a single credential (the daemon's caller-named probe).
+ */
+export async function fetchDaemonCredentialAvailability(
+  connection: CredentialStatusConnection,
+  options: { readonly key?: string; readonly fetchImpl?: FetchLike } = {},
+): Promise<CredentialAvailability> {
+  if (!connection.token) {
+    return { available: false, reason: 'No connected-host operator token; credential status is unavailable.' };
+  }
+  const fetchImpl = options.fetchImpl ?? (globalThis.fetch as FetchLike | undefined);
+  if (!fetchImpl) {
+    return { available: false, reason: 'Credential status unavailable right now.' };
+  }
+  const query = options.key ? `?key=${encodeURIComponent(options.key)}` : '';
+  const url = `${connection.baseUrl}${CREDENTIALS_ROUTE}${query}`;
+  try {
+    const response = await fetchImpl(url, {
+      method: 'GET',
+      headers: { authorization: `Bearer ${connection.token}` },
+      signal: AbortSignal.timeout(CREDENTIAL_STATUS_TIMEOUT_MS),
+    });
+    const text = await response.text();
+    let body: unknown = text;
+    try {
+      body = text.trim() ? JSON.parse(text) as unknown : {};
+    } catch {
+      body = text;
+    }
+    if (!response.ok) {
+      return deriveCredentialAvailability({
+        ok: false,
+        error: { code: machineCodeFromResponse(body, response.status), status: response.status },
+      });
+    }
+    return deriveCredentialAvailability({ ok: true, value: body });
+  } catch (error) {
+    return deriveCredentialAvailability({ ok: false, error });
+  }
+}

package/src/config/index.ts

@@ -55,3 +55,15 @@ export function getConfiguredSystemPrompt(configManager: Pick<ConfigManager, 'ge
 }
 
 export { getConfiguredApiKeys, resolveApiKeys } from '@pellux/goodvibes-sdk/platform/config';
+
+// W6-C1 (E7): the daemon-client credential STATUS read (secret-free, honest-degrade).
+// Value reads above stay local/env; only the status VISIBILITY path moves to the daemon.
+export {
+  deriveCredentialAvailability,
+  fetchDaemonCredentialAvailability,
+} from './credential-status.ts';
+export type {
+  CredentialAvailability,
+  CredentialStatusConnection,
+  CredentialStatusEntry,
+} from './credential-status.ts';

package/src/config/secrets.ts

@@ -16,6 +16,23 @@ import {
 import { isSecretRefInput } from '@pellux/goodvibes-sdk/platform/config';
 import { GOODVIBES_AGENT_SURFACE_ROOT } from './surface.ts';
 
+// W6-C1 host-vs-client split (E7 config sharing): this SecretsManager is the LOCAL-HOST
+// read path — pinned to GOODVIBES_AGENT_SURFACE_ROOT, it resolves secret VALUES from the
+// surface store/env for provider auth, unchanged. When the Agent acts as a CLIENT of an
+// adopted external daemon, credential *status* (configured/usable — never bytes) is read
+// over the wire via ./credential-status.ts (`fetchDaemonCredentialAvailability`), which
+// degrades honestly and never fabricates "configured". Only STATUS visibility moves to
+// the daemon path; value resolution stays here, local and env-only for API keys.
+export {
+  deriveCredentialAvailability,
+  fetchDaemonCredentialAvailability,
+} from './credential-status.ts';
+export type {
+  CredentialAvailability,
+  CredentialStatusConnection,
+  CredentialStatusEntry,
+} from './credential-status.ts';
+
 export type SecretsManagerOptions = Omit<SdkSecretsManagerOptions, 'surfaceRoot'>;
 
 const RAW_SECRET_LITERAL_PREFIX = '__GOODVIBES_LITERAL_V1__';

package/src/runtime/bootstrap-core.ts

@@ -26,7 +26,10 @@ import {
 } from '@/runtime/index.ts';
 import { loadBootstrapSystemPrompt, syncConfiguredServices } from '@/runtime/index.ts';
 import { registerBootstrapHookBridge } from '@/runtime/index.ts';
-import { createRuntimeServices, type RuntimeServices } from './services.ts';
+import { createRuntimeServices, foldAgentLegacyMemory, type RuntimeServices } from './services.ts';
+import { formatMemoryFoldReport } from '@pellux/goodvibes-sdk/platform/state';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
+import { importVibeFilesIntoMemoryOnce } from '../agent/vibe-file.ts';
 import { createUiRuntimeServices, type UiRuntimeServices } from './ui-services.ts';
 import { installAgentToolPolicyGuard } from '../tools/agent-tool-policy-guard.ts';
 import { registerAgentChannelSendTool } from '../tools/agent-channel-send-tool.ts';
@@ -345,6 +348,34 @@ export async function initializeBootstrapCore(
     memoryStore.close();
   });
 
+  // W6-C2 (E6): fold the agent's legacy per-surface memory into the canonical
+  // cross-surface store (id-keyed, idempotent, never deletes the legacy file) and
+  // SURFACE the fold report — migration honesty requires that what moved is visible,
+  // not silently swallowed. Non-fatal: a fold failure must never block startup.
+  try {
+    const foldReport = await foldAgentLegacyMemory(
+      services.memoryStore,
+      services.memoryEmbeddingRegistry,
+      services.shellPaths,
+    );
+    logger.info('agent legacy memory fold report', { report: formatMemoryFoldReport(foldReport) });
+  } catch (err) {
+    logger.warn('agent legacy memory fold failed (non-fatal)', { error: summarizeError(err) });
+  }
+
+  // W6-C2 (E6): ONE-TIME migration of discovered VIBE.md files into persona/constraint
+  // records, guarded by a persisted path→hash marker so it never re-imports the same
+  // file (which would create near-duplicate persona records). After this, the VIBE
+  // prompt is a PROJECTION of those records (buildVibeProjectionPrompt).
+  try {
+    const importedPersona = await importVibeFilesIntoMemoryOnce(services.memoryRegistry, services.shellPaths);
+    if (importedPersona > 0) {
+      logger.info('agent VIBE.md persona migration', { records: importedPersona });
+    }
+  } catch (err) {
+    logger.warn('agent VIBE.md persona migration failed (non-fatal)', { error: summarizeError(err) });
+  }
+
   const renderRequestRef = { value: (): void => {} };
   // R1: Coalescing render scheduler — collapses N same-microtask requestRender() calls into 1.
   // Also enforces a 16ms minimum interval to cap at ~60fps during streaming.

package/src/tools/agent-harness-prompt-context.ts

@@ -6,7 +6,7 @@ import { AgentPersonaRegistry, buildActivePersonaPrompt } from '../agent/persona
 import { buildProjectContextPrompt, discoverProjectContextFiles } from '../agent/project-context-files.ts';
 import { AgentRoutineRegistry, buildEnabledRoutinesPrompt, evaluateAgentRoutineReadiness } from '../agent/routine-registry.ts';
 import { AgentSkillRegistry, buildEnabledSkillsPrompt, evaluateAgentSkillBundleReadiness, evaluateAgentSkillReadiness } from '../agent/skill-registry.ts';
-import { buildVibePrompt, discoverVibeFiles } from '../agent/vibe-file.ts';
+import { buildVibeProjectionPrompt, discoverVibeFiles } from '../agent/vibe-file.ts';
 import type { PromptContextReceipt } from '../agent/prompt-context-receipts.ts';
 import type { CommandContext } from '../input/command-registry.ts';
 import { previewHarnessText } from './agent-harness-text.ts';
@@ -399,7 +399,10 @@ function promptContextSegments(context: CommandContext, includeParameters: boole
   }
 
   const vibe = discoverVibeFiles(shellPaths);
-  const vibePrompt = buildVibePrompt(shellPaths) ?? '';
+  // W6-C2 (E6): mirror the runtime — the VIBE prompt is a PROJECTION of persona records,
+  // not a file re-read (discoverVibeFiles stays for the file-discovery receipt below).
+  const vibeMemory = promptMemoryApi(context.clients?.agentKnowledgeApi?.memory);
+  const vibePrompt = (vibeMemory ? buildVibeProjectionPrompt(vibeMemory) : null) ?? '';
   const projectContext = discoverProjectContextFiles(shellPaths);
   const projectContextPrompt = buildProjectContextPrompt(shellPaths) ?? '';
   const personaSnapshot = AgentPersonaRegistry.fromShellPaths(shellPaths).snapshot();

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 = '1.5.6';
+let _version = '1.5.7';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {
     readonly version?: unknown;