@pellux/goodvibes-agent 0.1.117 → 1.0.1

package/docs/tools-and-commands.md

@@ -0,0 +1,123 @@
+# Tools and Commands
+
+GoodVibes Agent is an operator assistant TUI. Its command set is centered on main-conversation assistant work, isolated Agent Knowledge, local memory/notes/routines/skills/personas, approvals, automation visibility, and explicit delegation to GoodVibes TUI for build work.
+
+## Product Boundaries
+
+- Normal chat stays in the main Agent conversation.
+- Agent Knowledge uses only `/api/goodvibes-agent/knowledge/*`.
+- Agent never falls back to default knowledge or arbitrary non-Agent knowledge spaces.
+- Local memory, notes, routines, skills, and personas remain Agent-local until a stable shared registry contract exists.
+- Runtime hosting is external. Agent connects to it and reports health; it does not start, stop, restart, or install it.
+- Delegated review is not a default reasoning path. It is requested only when the user explicitly asks for build, implementation, fix, or review work.
+- Code-building work is delegated to GoodVibes TUI through public shared-session/task contracts.
+
+## TUI-First Operator Surface
+
+The Agent workspace is the product surface. Slash commands are power-user routes inside the TUI, and package CLI subcommands are scriptable mirrors. New user-facing features should appear in the workspace first.
+
+High-signal Agent TUI paths:
+
+- `/help` for registry-driven command discovery.
+- `/health` and `/auth` for runtime/auth/SDK diagnostics inside the TUI.
+- `/model` and `/provider` for provider/model selection and visibility.
+- `/agent` for the fullscreen operator workspace: setup, provider/model, Agent Knowledge, memory, notes, personas, skills, routines, channels, MCP/tools, secrets, voice/media, work state, automation, and build delegation.
+- Agent Workspace -> Research for read-only web research, URL inspection, source triage, and explicit source-to-Agent-Knowledge handoff.
+- Agent Workspace -> Notes for local source-triage notes, temporary decisions, and operator handoff. Notes do not write memory or Agent Knowledge by themselves; reviewed notes can prefill memory, skills, routines, personas, or an isolated Agent Knowledge URL ingest.
+- `/knowledge` for isolated Agent Knowledge ask, search, status, source/node/issue inspection, connector inspection, and confirmed ingest/reindex actions.
+- `/memory`, `/routines`, `/skills`, and `/personas` for Agent-local context and reusable operator behavior.
+- `/plan` for Agent-owned workspace planning state in the main conversation.
+- `/workplan` for durable task status over public work-plan routes.
+- `/approvals` for pending approval visibility and explicit approval actions.
+- `/schedule` for schedule visibility plus narrow explicit-user-action flows.
+- `/channels` for channel readiness and one-message confirmed channel delivery.
+- `/media` for media provider readiness and confirmed image/video artifact generation.
+- `/delegate` for explicit build/fix/review handoff to GoodVibes TUI.
+- `/mcp`, `/config`, `/settings`, and setup workspaces for Agent-local configuration.
+
+The installed `goodvibes-agent` command launches the TUI by default. Subcommands such as `status`, `compat`, `knowledge ...`, `ask <question>`, and `search <query>` are secondary scriptable equivalents for diagnostics and automation over the same Agent workspace features.
+
+Host-management and coding-first commands that would imply connected-host lifecycle ownership, separate Agent job creation, execution-isolation ownership, worktree control, or implicit delegated review must remain blocked, read-only, or delegation-only unless they are intentionally adapted to Agent policy.
+
+The main composer supports inline context references. Type `@path/to/file`, `@path/to/folder`, or `@https://example.test/page` in a normal prompt to add bounded context for that turn. `!@path/to/file` remains the raw file-injection form. These references do not ingest anything into Agent Knowledge unless the user explicitly runs a Knowledge ingest action.
+
+The Research workspace submits web research and URL inspection forms to the normal main conversation. These requests are read-only by default, may use connected web tools when the user asks, and do not ingest sources. Use confirmed Agent Knowledge ingest actions only after a source should become durable Agent-owned knowledge.
+
+Local memory capture/add commands are explicit Agent-local actions. Deletes, imports/exports, record linking, review-state changes, and promotion across memory scopes require `--yes`.
+
+## Agent Knowledge
+
+`/knowledge ask <query>` asks the isolated Agent Knowledge environment for a source-backed answer through `/api/goodvibes-agent/knowledge/ask`.
+
+`/knowledge search <query>` searches the same isolated Agent environment through `/api/goodvibes-agent/knowledge/search`.
+
+`/knowledge ingest-url <url> --yes` ingests into Agent Knowledge through `/api/goodvibes-agent/knowledge/ingest/url`. Knowledge ingestion, imports, issue review, reindex, and consolidation are Agent-owned mutations and require `--yes`.
+
+The Knowledge workspace exposes status, source library, connector review, ask, search, and confirmed ingest forms. Scriptable equivalents such as `goodvibes-agent knowledge list --kind sources|nodes|issues`, `goodvibes-agent knowledge get <id>`, `goodvibes-agent knowledge connectors`, and `goodvibes-agent knowledge map` are read-only CLI inspection paths over the same isolated Agent route family.
+
+Workspace ingest forms are the primary user workflow. Scriptable equivalents such as `goodvibes-agent knowledge import-urls <path> --yes`, `goodvibes-agent knowledge import-bookmarks <path> --yes`, and `goodvibes-agent knowledge reindex --yes` are confirmed Agent Knowledge maintenance paths. They call only `/api/goodvibes-agent/knowledge/*`.
+
+The Agent command layer rejects flags that would route knowledge work into another space, including `--space`, `--knowledge-space`, `--knowledge-space-id`, and `--include-all-spaces`. If Agent Knowledge is unavailable, the command fails closed instead of querying a default store.
+
+## Media Artifacts
+
+Agent Workspace -> Voice & Media is the primary media path. Use `Generate media` for a confirmed form that calls configured media providers and stores outputs as GoodVibes artifacts.
+
+`/media providers` lists media provider readiness. `/media generate [--provider <id>] [--model <id>] [--mime <mime>] <prompt> --yes` is the power-user mirror for confirmed image/video generation. Media generation output returns artifact ids and metadata; it does not print inline base64 and does not write to default knowledge or non-Agent knowledge segments.
+
+## Planning
+
+`/plan` inspects or seeds Agent workspace planning state. The planning loop belongs to the main Agent conversation: the Agent asks focused questions, records decisions and gaps, and keeps execution separate until the user gives an explicit action.
+
+The SDK planning service may expose a namespace such as `project:<projectId>` because that is the stable contract shape. In Agent UI and docs this is treated as a planning namespace, not as permission to query default knowledge or another product knowledge segment.
+
+Use `/workplan` when the work already has concrete tasks and needs durable status tracking rather than another planning interview.
+
+## Delegation
+
+`/delegate` is for explicit build, fix, review, or implementation work. It sends a single delegated request to GoodVibes TUI/shared-session routes with the original user ask and execution intent. Agent does not create coding-role Agent jobs and does not run delegated review by default.
+
+Use `/delegate --review` only when the user explicitly asks for review or when the delegated build/fix/review request explicitly calls for review.
+
+## Approvals And Automation
+
+Approvals and automation are safe by default:
+
+- list/status views are read-only;
+- mutating routes require exact commands and explicit confirmation such as `--yes`;
+- no chat turn silently runs approval, schedule, or automation mutations;
+- unavailable routes return structured errors rather than fallback behavior.
+
+Workspace forms are the primary path for approval and automation actions:
+
+- Agent Workspace -> Work & Approvals -> Approve request / Deny request / Cancel request
+- Agent Workspace -> Automation -> Run job now / Pause job / Resume job
+- Agent Workspace -> Automation -> Cancel run / Retry run / Run schedule now
+
+Power-user slash mirrors are exact and confirmation-gated:
+
+- `/approval approve <approval-id> [--note <text>] [--remember|--no-remember] --yes`
+- `/approval deny <approval-id> [--note <text>] [--remember|--no-remember] --yes`
+- `/approval cancel <approval-id> [--note <text>] [--remember|--no-remember] --yes`
+- `/automation job run <job-id> --yes`
+- `/automation job pause <job-id> --yes`
+- `/automation job resume <job-id> --yes`
+- `/automation run cancel <run-id> --yes`
+- `/automation run retry <run-id> --yes`
+- `/automation schedule run <schedule-id> --yes`
+- `/schedule run <schedule-id> --yes`
+
+Routine promotion is an explicit scheduling bridge: local routines stay local during normal use, and promotion creates a schedule only after a user runs the exact command with `--yes`. The generated scheduled prompt keeps Agent Knowledge isolated and forbids default knowledge or non-Agent knowledge fallback. Delivery is opt-in with explicit flags such as `--delivery-channel`, `--delivery-route`, `--delivery-webhook`, or `--delivery-link`; no delivery target is inferred from chat.
+
+## Channels
+
+Agent Workspace -> Channels is the primary channel path. It shows readiness, setup, account, policy, and status views without rendering secret values. `Send channel message` opens a confirmed form for one delivery target.
+
+`/channels send --channel <surface[:route[:label]]> --message <text> --yes` sends one explicit message through configured delivery strategies. `--route`, `--webhook`, and `--link` are alternate one-target forms. Channel sends do not create routes, authorize accounts, manage connected-host hosting, use default knowledge, use non-Agent knowledge segments, create separate Agent jobs, or run delegated review.
+
+## Related Docs
+
+- [Getting started](getting-started.md)
+- [Connected host](connected-host.md)
+- [Knowledge, artifacts, and multimodal](knowledge-artifacts-and-multimodal.md)
+- [Release and publishing](release-and-publishing.md)

package/docs/voice-and-live-tts.md

@@ -0,0 +1,51 @@
+# Voice and Live TTS
+
+GoodVibes Agent supports spoken turns as an Agent TUI feature. Text output remains primary; voice is an additional local playback path for a normal assistant turn.
+
+## Commands
+
+```text
+/tts <prompt>
+/tts stop
+/config tts
+/config tts.provider
+/config tts.voice
+/config tts.llmProvider
+/config tts.llmModel
+```
+
+`/tts <prompt>` submits the prompt through the normal Agent conversation path. It uses the active chat provider/model unless a separate spoken-turn model override is configured.
+
+`/tts stop` cancels queued spoken output and active playback without cancelling the text transcript.
+
+`/config tts` opens the fullscreen configuration workspace for streaming provider, voice, and spoken-turn model routing.
+
+## Playback Requirements
+
+Live playback streams audio to a local player. Install one of:
+
+- `mpv`;
+- `ffplay`.
+
+If neither player is on `PATH`, the Agent still submits and renders the normal text response. Audio is skipped with a concise status message.
+
+## Provider Routing
+
+Voice uses providers that advertise streaming TTS capability through the runtime. Agent does not hardcode provider behavior.
+
+Useful setup path:
+
+```text
+/config tts.provider
+/config tts.voice
+/config tts.llmProvider
+/config tts.llmModel
+```
+
+Leaving `tts.voice` empty lets the provider choose its default voice.
+
+## Knowledge Boundary
+
+Spoken responses are conversation output. They are not automatically written to Agent Knowledge, local memory, default knowledge, or any other product segment.
+
+If a spoken result should become durable, store it through an explicit Agent memory command or an Agent Knowledge ingestion path.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pellux/goodvibes-agent",
-  "version": "0.1.117",
+  "version": "1.0.1",
   "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",
@@ -22,10 +22,7 @@
     "tsconfig.json",
     "README.md",
     "CHANGELOG.md",
-    "docs/README.md",
-    "docs/getting-started.md",
-    "docs/connected-host.md",
-    "docs/release-and-publishing.md"
+    "docs/*.md"
   ],
   "scripts": {
     "dev": "bun run src/main.ts",

package/src/agent/channel-delivery.ts

@@ -0,0 +1,201 @@
+import type {
+  ChannelDeliveryRequest,
+  ChannelDeliveryRouter,
+  ChannelDeliverySurfaceKind,
+  ChannelDeliveryTarget,
+} from '@pellux/goodvibes-sdk/platform/channels';
+
+type AgentChannelDeliveryRouter = Pick<ChannelDeliveryRouter, 'deliver' | 'listStrategies'>;
+type AgentChannelDeliverySurfaceKind = ChannelDeliverySurfaceKind | 'telephony';
+type AgentChannelDeliveryTarget = Omit<ChannelDeliveryTarget, 'surfaceKind'> & {
+  readonly surfaceKind?: AgentChannelDeliverySurfaceKind;
+};
+type AgentChannelDeliveryRequest = Omit<ChannelDeliveryRequest, 'target'> & {
+  readonly target: AgentChannelDeliveryTarget;
+};
+
+export interface AgentChannelDeliveryInput {
+  readonly message: string;
+  readonly title?: string;
+  readonly channel?: string;
+  readonly route?: string;
+  readonly webhook?: string;
+  readonly link?: string;
+}
+
+export interface AgentChannelDeliveryPreview {
+  readonly message: string;
+  readonly title: string;
+  readonly target: AgentChannelDeliveryTarget;
+  readonly request: AgentChannelDeliveryRequest;
+}
+
+export interface AgentChannelDeliveryResult {
+  readonly responseId?: string;
+  readonly message: string;
+  readonly title: string;
+  readonly target: AgentChannelDeliveryTarget;
+  readonly strategyCount: number;
+}
+
+const DELIVERY_SURFACE_KINDS: readonly AgentChannelDeliverySurfaceKind[] = [
+  'tui',
+  'web',
+  'slack',
+  'discord',
+  'ntfy',
+  'webhook',
+  'telegram',
+  'google-chat',
+  'signal',
+  'whatsapp',
+  'telephony',
+  'imessage',
+  'msteams',
+  'bluebubbles',
+  'mattermost',
+  'matrix',
+  'service',
+];
+
+function readText(value: string | undefined): string | undefined {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : undefined;
+}
+
+function isDeliverySurfaceKind(value: string): value is AgentChannelDeliverySurfaceKind {
+  return DELIVERY_SURFACE_KINDS.includes(value as AgentChannelDeliverySurfaceKind);
+}
+
+function parseChannelTarget(raw: string): AgentChannelDeliveryTarget {
+  const [surfaceKind = '', routeId, label] = raw.split(':');
+  if (!isDeliverySurfaceKind(surfaceKind)) {
+    throw new Error(`Unsupported delivery channel "${surfaceKind}".`);
+  }
+  return {
+    kind: 'surface',
+    surfaceKind,
+    ...(readText(routeId) ? { routeId: readText(routeId) } : {}),
+    ...(readText(label) ? { label: readText(label) } : {}),
+  };
+}
+
+function parseRouteTarget(raw: string): AgentChannelDeliveryTarget {
+  const [routeId = '', label] = raw.split(':');
+  const normalizedRouteId = readText(routeId);
+  if (!normalizedRouteId) throw new Error('Route delivery target requires a route id.');
+  return {
+    kind: 'surface',
+    routeId: normalizedRouteId,
+    ...(readText(label) ? { label: readText(label) } : {}),
+  };
+}
+
+function parseWebhookTarget(raw: string): AgentChannelDeliveryTarget {
+  const normalized = readText(raw);
+  if (!normalized) throw new Error('Webhook delivery target requires a URL.');
+  try {
+    const url = new URL(normalized);
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') throw new Error('bad protocol');
+  } catch {
+    throw new Error('Webhook delivery target must be a valid http(s) URL.');
+  }
+  return { kind: 'webhook', address: normalized };
+}
+
+function parseLinkTarget(raw: string): AgentChannelDeliveryTarget {
+  const normalized = readText(raw);
+  if (!normalized) throw new Error('Link delivery target requires a URL or label.');
+  return { kind: 'link', address: normalized };
+}
+
+function selectedTargetInputs(input: AgentChannelDeliveryInput): readonly string[] {
+  return [input.channel, input.route, input.webhook, input.link].map(readText).filter((value): value is string => Boolean(value));
+}
+
+export function buildAgentChannelDeliveryPreview(input: AgentChannelDeliveryInput): AgentChannelDeliveryPreview {
+  const message = readText(input.message);
+  if (!message) throw new Error('Channel delivery message is required.');
+  const targets = selectedTargetInputs(input);
+  if (targets.length === 0) throw new Error('Choose one delivery target: channel, route, webhook, or link.');
+  if (targets.length > 1) throw new Error('Choose exactly one delivery target.');
+
+  const channel = readText(input.channel);
+  const route = readText(input.route);
+  const webhook = readText(input.webhook);
+  const link = readText(input.link);
+  const target = channel
+    ? parseChannelTarget(channel)
+    : route
+      ? parseRouteTarget(route)
+      : webhook
+        ? parseWebhookTarget(webhook)
+        : parseLinkTarget(link ?? '');
+  const title = readText(input.title) ?? 'GoodVibes Agent message';
+  return {
+    message,
+    title,
+    target,
+    request: {
+      target,
+      body: message,
+      title,
+      jobId: 'agent-channel-send',
+      runId: `agent-channel-send-${Date.now()}`,
+      status: 'completed',
+      includeLinks: true,
+      metadata: {
+        product: 'goodvibes-agent',
+        source: 'agent-channel-send',
+      },
+    },
+  };
+}
+
+export async function deliverAgentChannelMessage(
+  router: AgentChannelDeliveryRouter,
+  input: AgentChannelDeliveryInput,
+): Promise<AgentChannelDeliveryResult> {
+  const preview = buildAgentChannelDeliveryPreview(input);
+  const responseId = await router.deliver(preview.request as ChannelDeliveryRequest);
+  return {
+    responseId,
+    message: preview.message,
+    title: preview.title,
+    target: preview.target,
+    strategyCount: router.listStrategies().length,
+  };
+}
+
+function formatTarget(target: AgentChannelDeliveryTarget): string {
+  if (target.kind === 'surface') {
+    const base = target.surfaceKind ?? 'route';
+    const details = [
+      target.routeId ? `route ${target.routeId}` : '',
+      target.label ? `label ${target.label}` : '',
+    ].filter(Boolean);
+    return `${base}${details.length > 0 ? ` (${details.join(', ')})` : ''}`;
+  }
+  return target.address ? `${target.kind} ${target.address}` : target.kind;
+}
+
+export function formatAgentChannelDeliveryPreview(preview: AgentChannelDeliveryPreview, strategyCount: number): string {
+  return [
+    'Agent channel delivery preview',
+    `  title ${preview.title}`,
+    `  target ${formatTarget(preview.target)}`,
+    `  strategies ${strategyCount}`,
+    `  message ${preview.message}`,
+    '  policy external delivery requires an explicit user request and confirmation',
+  ].join('\n');
+}
+
+export function formatAgentChannelDeliveryResult(result: AgentChannelDeliveryResult): string {
+  return [
+    'Agent channel delivery sent',
+    `  title ${result.title}`,
+    `  target ${formatTarget(result.target)}`,
+    `  strategies ${result.strategyCount}`,
+    ...(result.responseId ? [`  response ${result.responseId}`] : []),
+  ].join('\n');
+}

package/src/agent/media-generation.ts

@@ -0,0 +1,159 @@
+import type { ArtifactCreateInput, ArtifactDescriptor, ArtifactStore } from '@pellux/goodvibes-sdk/platform/artifacts';
+import type {
+  MediaArtifact,
+  MediaGenerationRequest,
+  MediaProvider,
+  MediaProviderRegistry,
+} from '@pellux/goodvibes-sdk/platform/media';
+
+export interface AgentMediaGenerationInput {
+  readonly prompt: string;
+  readonly providerId?: string;
+  readonly modelId?: string;
+  readonly outputMimeType?: string;
+  readonly options?: Record<string, unknown>;
+}
+
+export interface AgentGeneratedMediaArtifact {
+  readonly artifactId: string;
+  readonly mimeType: string;
+  readonly filename?: string;
+  readonly sizeBytes: number;
+  readonly sourceUri?: string;
+}
+
+export interface AgentMediaGenerationResult {
+  readonly providerId: string;
+  readonly artifacts: readonly AgentGeneratedMediaArtifact[];
+  readonly metadata: Record<string, unknown>;
+}
+
+function readText(value: string | undefined): string | undefined {
+  const trimmed = value?.trim();
+  return trimmed ? trimmed : undefined;
+}
+
+function ensurePrompt(prompt: string): string {
+  const trimmed = prompt.trim();
+  if (!trimmed) throw new Error('Media generation prompt is required.');
+  return trimmed;
+}
+
+function findGenerationProvider(registry: MediaProviderRegistry, providerId: string | undefined): MediaProvider {
+  const provider = registry.findProvider('generate', readText(providerId));
+  if (!provider?.generate) {
+    const available = registry
+      .list()
+      .filter((entry) => entry.capabilities.includes('generate'))
+      .map((entry) => entry.id)
+      .join(', ');
+    throw new Error(providerId
+      ? `Media generation provider is unavailable or not configured for generation: ${providerId}.`
+      : `No media generation provider is available${available ? `. Available providers: ${available}` : '.'}`);
+  }
+  return provider;
+}
+
+function filenameForArtifact(artifact: MediaArtifact, index: number): string {
+  if (readText(artifact.filename)) return artifact.filename as string;
+  if (artifact.mimeType.includes('video')) return `agent-generated-${index + 1}.mp4`;
+  if (artifact.mimeType.includes('image')) return `agent-generated-${index + 1}.png`;
+  return `agent-generated-${index + 1}`;
+}
+
+function artifactCreateInput(
+  providerId: string,
+  artifact: MediaArtifact,
+  index: number,
+): ArtifactCreateInput {
+  const filename = filenameForArtifact(artifact, index);
+  const metadata = {
+    ...artifact.metadata,
+    product: 'goodvibes-agent',
+    source: 'agent-media-generation',
+    providerId,
+  };
+  const common = {
+    mimeType: artifact.mimeType,
+    filename,
+    metadata,
+  };
+  if (readText(artifact.dataBase64)) {
+    return {
+      ...common,
+      dataBase64: artifact.dataBase64,
+      sourceUri: artifact.uri,
+      acquisitionMode: 'inline-data',
+    };
+  }
+  if (readText(artifact.uri)) {
+    return {
+      ...common,
+      uri: artifact.uri,
+      sourceUri: artifact.uri,
+      acquisitionMode: 'remote-fetch',
+      fetchMode: 'public-only',
+    };
+  }
+  throw new Error(`Generated media artifact ${index + 1} did not include inline data or a fetchable URI.`);
+}
+
+function toGeneratedArtifact(descriptor: ArtifactDescriptor): AgentGeneratedMediaArtifact {
+  return {
+    artifactId: descriptor.id,
+    mimeType: descriptor.mimeType,
+    ...(descriptor.filename ? { filename: descriptor.filename } : {}),
+    sizeBytes: descriptor.sizeBytes,
+    ...(descriptor.sourceUri ? { sourceUri: descriptor.sourceUri } : {}),
+  };
+}
+
+function buildProviderRequest(input: AgentMediaGenerationInput): MediaGenerationRequest {
+  return {
+    prompt: ensurePrompt(input.prompt),
+    ...(readText(input.outputMimeType) ? { outputMimeType: readText(input.outputMimeType) } : {}),
+    ...(readText(input.modelId) ? { modelId: readText(input.modelId) } : {}),
+    ...(input.options ? { options: input.options } : {}),
+    metadata: {
+      product: 'goodvibes-agent',
+      source: 'agent-media-generation',
+    },
+  };
+}
+
+export async function generateAgentMedia(
+  registry: MediaProviderRegistry,
+  artifactStore: Pick<ArtifactStore, 'create'>,
+  input: AgentMediaGenerationInput,
+): Promise<AgentMediaGenerationResult> {
+  const provider = findGenerationProvider(registry, input.providerId);
+  const generate = provider.generate;
+  if (!generate) throw new Error(`Media generation provider is unavailable or not configured for generation: ${provider.id}.`);
+  const generated = await generate(buildProviderRequest(input));
+  const artifacts: AgentGeneratedMediaArtifact[] = [];
+  for (const [index, artifact] of generated.artifacts.entries()) {
+    const descriptor = await artifactStore.create(artifactCreateInput(generated.providerId, artifact, index));
+    artifacts.push(toGeneratedArtifact(descriptor));
+  }
+  if (artifacts.length === 0) throw new Error(`Media provider ${generated.providerId} did not return artifacts.`);
+  return {
+    providerId: generated.providerId,
+    artifacts,
+    metadata: generated.metadata,
+  };
+}
+
+export function formatAgentMediaGenerationResult(result: AgentMediaGenerationResult): string {
+  return [
+    'Agent media generated',
+    `  provider ${result.providerId}`,
+    `  artifacts ${result.artifacts.length}`,
+    ...result.artifacts.map((artifact, index) => [
+      `  ${index + 1}. ${artifact.artifactId}`,
+      `     type ${artifact.mimeType}`,
+      `     size ${artifact.sizeBytes} bytes`,
+      ...(artifact.filename ? [`     filename ${artifact.filename}`] : []),
+      ...(artifact.sourceUri ? [`     source ${artifact.sourceUri}`] : []),
+    ].join('\n')),
+  ].join('\n');
+}

package/src/agent/memory-prompt.ts

@@ -1,5 +1,4 @@
 import type { MemoryRecord, MemoryRegistry } from '@pellux/goodvibes-sdk/platform/state';
-
 const DEFAULT_LIMIT = 10;
 export const MIN_PROMPT_MEMORY_CONFIDENCE = 50;