create-walle 0.9.11 → 0.9.13

package/template/wall-e/llm/google.js

@@ -9,7 +9,37 @@ const GEMINI_CLIENT_SECRET = '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';
 let _cachedToken = null;
 let _tokenExpiresAt = 0;
 
-async function refreshOAuthToken(refreshToken) {
+function providerAbortError() {
+  const err = new Error('provider request aborted');
+  err.name = 'AbortError';
+  return err;
+}
+
+function throwIfAborted(signal) {
+  if (signal?.aborted) throw providerAbortError();
+}
+
+function delayWithAbort(ms, signal) {
+  throwIfAborted(signal);
+  return new Promise((resolve, reject) => {
+    let timer = null;
+    const cleanup = () => {
+      if (timer) clearTimeout(timer);
+      if (signal) signal.removeEventListener('abort', onAbort);
+    };
+    const onAbort = () => {
+      cleanup();
+      reject(providerAbortError());
+    };
+    timer = setTimeout(() => {
+      cleanup();
+      resolve();
+    }, ms);
+    if (signal) signal.addEventListener('abort', onAbort, { once: true });
+  });
+}
+
+async function refreshOAuthToken(refreshToken, signal) {
   if (_cachedToken && Date.now() < _tokenExpiresAt - 60000) return _cachedToken;
   const resp = await fetch('https://oauth2.googleapis.com/token', {
     method: 'POST',
@@ -18,6 +48,7 @@ async function refreshOAuthToken(refreshToken) {
       client_id: GEMINI_CLIENT_ID, client_secret: GEMINI_CLIENT_SECRET,
       refresh_token: refreshToken, grant_type: 'refresh_token',
     }),
+    ...(signal ? { signal } : {}),
   });
   const data = await resp.json();
   if (!data.access_token) throw new Error('Token refresh failed: ' + (data.error_description || data.error));
@@ -107,6 +138,7 @@ function messagesToGemini(messages) {
  */
 function createGoogleProvider(config = {}) {
   const isOAuth = config.authMode === 'oauth';
+  const GenAI = config._GoogleGenAI || GoogleGenAI;
   if (!isOAuth && config.apiKey && config.apiKey.startsWith('ya29.')) {
     console.warn('[google] Stored key is a Gemini CLI OAuth token (ya29.*). ' +
       'These tokens use Google\'s private Code Assist API and cannot authenticate ' +
@@ -117,7 +149,7 @@ function createGoogleProvider(config = {}) {
     const httpOptions = accessToken
       ? { headers: { 'Authorization': `Bearer ${accessToken}` } }
       : undefined;
-    return new GoogleGenAI({ apiKey: 'unused', httpOptions });
+    return new GenAI({ apiKey: 'unused', httpOptions });
   }
 
   // Build GenAI client — for OAuth we pass Bearer header instead of apiKey
@@ -125,7 +157,7 @@ function createGoogleProvider(config = {}) {
   if (isOAuth) {
     genai = makeOAuthClient(config.apiKey);
   } else {
-    genai = new GoogleGenAI({ apiKey: config.apiKey });
+    genai = new GenAI({ apiKey: config.apiKey });
   }
 
   return {
@@ -170,7 +202,7 @@ function createGoogleProvider(config = {}) {
       let activeGenai = genai;
       if (isOAuth && config.refreshToken) {
         try {
-          const freshToken = await refreshOAuthToken(config.refreshToken);
+          const freshToken = await refreshOAuthToken(config.refreshToken, signal);
           activeGenai = makeOAuthClient(freshToken);
         } catch (e) {
           console.warn('[google] OAuth token refresh failed:', e.message);
@@ -186,16 +218,18 @@ function createGoogleProvider(config = {}) {
       let raw;
       const MAX_RETRIES = 3;
       for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+        throwIfAborted(signal);
         try {
           raw = await activeGenai.models.generateContent(requestConfig);
           break;
         } catch (err) {
+          throwIfAborted(signal);
           const status = err.status || err.code || 0;
           const message = err.message || '';
           if (attempt < MAX_RETRIES && isRetryable(status, message)) {
             const delay = parseRetryDelay(null, attempt);
             console.log(`[google] Retrying (${attempt + 1}/${MAX_RETRIES}) after ${delay}ms: ${message.slice(0, 100)}`);
-            await new Promise(r => setTimeout(r, delay));
+            await delayWithAbort(delay, signal);
             continue;
           }
           throw err;

package/template/wall-e/llm/ollama.js

@@ -148,7 +148,7 @@ function createOllamaProvider(config = {}) {
           .map((m) => ({
             id: m.name,
             name: m.name,
-            capabilities: ['code'],
+            capabilities: ['chat', 'code', 'tools'],
             size: m.size,
           }));
       } catch {

package/template/wall-e/llm/ollama.plugin.json

@@ -11,7 +11,7 @@
   "modelPrefixes": [],
   "capabilities": {
     "chat": true,
-    "tools": false,
+    "tools": true,
     "vision": false,
     "thinking": false,
     "streaming": true,

package/template/wall-e/llm/provider-availability.js

@@ -42,6 +42,16 @@ class ProviderAvailability {
     return this._providers.get(id) || null;
   }
 
+  getProviderForType(providerType) {
+    return [...this._providers.values()].find(p => p.providerType === providerType || p.providerId === providerType) || null;
+  }
+
+  isProviderUsable(idOrType) {
+    const state = this.getProviderState(idOrType) || this.getProviderForType(idOrType);
+    if (!state) return true;
+    return state.status !== 'unhealthy';
+  }
+
   /**
    * Return all registered providers.
    */

package/template/wall-e/llm/provider-error.js

@@ -0,0 +1,269 @@
+'use strict';
+
+const MAX_RAW_MESSAGE_CHARS = 2000;
+
+const PROVIDER_LABELS = {
+  anthropic: 'Anthropic',
+  openai: 'OpenAI',
+  google: 'Google',
+  deepseek: 'DeepSeek',
+  ollama: 'Ollama',
+  mlx: 'MLX',
+};
+
+function providerLabel(provider) {
+  const key = String(provider || '').toLowerCase();
+  return PROVIDER_LABELS[key] || provider || 'AI provider';
+}
+
+function redactSecrets(value) {
+  return String(value || '')
+    .replace(/\bsk-[A-Za-z0-9_-]{12,}\b/g, 'sk-...redacted')
+    .replace(/\bya29\.[A-Za-z0-9._-]{12,}\b/g, 'ya29...redacted')
+    .replace(/\bAIza[A-Za-z0-9_-]{20,}\b/g, 'AIza...redacted')
+    .replace(/(api[_-]?key["'\s:=]+)[^"',\s]+/gi, '$1...redacted')
+    .slice(0, MAX_RAW_MESSAGE_CHARS);
+}
+
+function tryJson(value) {
+  if (!value || typeof value !== 'string') return null;
+  try { return JSON.parse(value); } catch { return null; }
+}
+
+function collectStrings(value, out = []) {
+  if (value == null) return out;
+  if (typeof value === 'string') {
+    out.push(value);
+    const parsed = tryJson(value);
+    if (parsed) collectStrings(parsed, out);
+    return out;
+  }
+  if (typeof value === 'number' || typeof value === 'boolean') {
+    out.push(String(value));
+    return out;
+  }
+  if (Array.isArray(value)) {
+    value.forEach((item) => collectStrings(item, out));
+    return out;
+  }
+  if (typeof value === 'object') {
+    for (const key of ['message', 'error', 'type', 'code', 'status', 'statusCode', 'details', 'body']) {
+      if (Object.prototype.hasOwnProperty.call(value, key)) collectStrings(value[key], out);
+    }
+  }
+  return out;
+}
+
+function extractStatus(err) {
+  const candidates = [
+    err?.status,
+    err?.statusCode,
+    err?.response?.status,
+    err?.response?.statusCode,
+    err?.error?.status,
+    err?.error?.statusCode,
+  ];
+  for (const candidate of candidates) {
+    const n = Number(candidate);
+    if (Number.isFinite(n) && n >= 100 && n < 600) return n;
+  }
+  const message = String(err?.message || err || '');
+  const m = message.match(/\b(?:api error|http|status)\s*[:#]?\s*(\d{3})\b/i);
+  return m ? Number(m[1]) : null;
+}
+
+function extractRetryAfter(err) {
+  const headers = err?.headers || err?.response?.headers;
+  if (!headers) return null;
+  const get = typeof headers.get === 'function'
+    ? (name) => headers.get(name)
+    : (name) => headers[name] || headers[name.toLowerCase()];
+  const retryAfterMs = get('retry-after-ms');
+  if (retryAfterMs && !Number.isNaN(Number(retryAfterMs))) return `${Math.round(Number(retryAfterMs) / 1000)}s`;
+  const retryAfter = get('retry-after');
+  if (!retryAfter) return null;
+  const seconds = Number(retryAfter);
+  if (!Number.isNaN(seconds)) return `${Math.round(seconds)}s`;
+  const date = Date.parse(retryAfter);
+  if (!Number.isNaN(date)) {
+    const delta = Math.max(0, date - Date.now());
+    return `${Math.ceil(delta / 1000)}s`;
+  }
+  return String(retryAfter).slice(0, 80);
+}
+
+function buildRawMessage(err) {
+  const pieces = [];
+  collectStrings(err?.responseBody, pieces);
+  collectStrings(err?.body, pieces);
+  collectStrings(err?.error, pieces);
+  collectStrings(err?.cause, pieces);
+  collectStrings(err?.message || err, pieces);
+  const unique = [...new Set(pieces.map((part) => String(part || '').trim()).filter(Boolean))];
+  return redactSecrets(unique.join('\n'));
+}
+
+function classifyType(status, lower) {
+  if (/insufficient[_ -]?quota|quota exceeded|quota_exceeded|resource[_ -]?exhausted|billing|credit|prepayment credits are depleted/i.test(lower)) return 'quota_exceeded';
+  if (status === 429 || /rate[_ -]?limit|too many requests|too_many_requests|rate_limit/i.test(lower)) return 'rate_limited';
+  if (status === 401 || status === 403 || /invalid[_ -]?(api[_ -]?)?key|unauthori[sz]ed|forbidden|authentication|auth token|token refresh failed|permission denied/i.test(lower)) return 'auth_error';
+  if (status === 404 || /model .*not found|not_found_error|model_not_found|does not exist|unknown model/i.test(lower)) return 'model_unavailable';
+  if (/context length exceeded|context_length_exceeded|maximum context|token limit/i.test(lower)) return 'context_window';
+  if (status === 408 || /timeout|timed out|etimedout|aborterror|aborted/i.test(lower)) return 'timeout';
+  if (status === 529 || status === 503 || /overloaded|service unavailable|temporarily unavailable|unavailable/i.test(lower)) return 'provider_unavailable';
+  if (/fetch failed|network|eai_again|enotfound|econnreset|socket hang up|connection refused|econnrefused/i.test(lower)) return 'network';
+  if (status && status >= 500) return 'provider_unavailable';
+  if (status && status >= 400) return 'provider_rejected';
+  return 'provider_error';
+}
+
+function messageForType(type) {
+  switch (type) {
+    case 'rate_limited':
+      return {
+        title: 'AI provider rate limited',
+        body: 'The provider rejected the request because it is rate limited. Wait and retry, or switch provider/model in Setup.',
+      };
+    case 'quota_exceeded':
+      return {
+        title: 'AI provider quota exhausted',
+        body: 'The provider rejected the request because the account quota or credits are exhausted. Update billing or switch provider/model in Setup.',
+      };
+    case 'auth_error':
+      return {
+        title: 'AI provider authentication failed',
+        body: 'The provider rejected the configured credential. Update the API key/token in Setup, then retry.',
+      };
+    case 'model_unavailable':
+      return {
+        title: 'AI model unavailable',
+        body: 'The selected model is not available from the configured provider. Pick another model in Setup, then retry.',
+      };
+    case 'context_window':
+      return {
+        title: 'AI request exceeded context',
+        body: 'The provider rejected the request because the conversation or attachments exceed the model context window. Shorten the prompt or switch to a larger-context model.',
+      };
+    case 'timeout':
+      return {
+        title: 'AI provider timed out',
+        body: 'The provider did not answer before the timeout. Retry, or switch provider/model if this keeps happening.',
+      };
+    case 'network':
+      return {
+        title: 'AI provider network error',
+        body: 'Wall-E could not reach the provider endpoint. Check connectivity, base URL, or local provider status, then retry.',
+      };
+    case 'provider_unavailable':
+      return {
+        title: 'AI provider unavailable',
+        body: 'The provider is currently unavailable or overloaded. Retry later, or switch provider/model in Setup.',
+      };
+    case 'provider_unavailable_local':
+      return {
+        title: 'No AI provider available',
+        body: 'Providers are configured, but every provider is currently marked unhealthy. Check Setup or wait for health checks to recover.',
+      };
+    default:
+      return {
+        title: 'AI provider failed',
+        body: 'Wall-E could not get a response from the configured provider. Review the raw provider error, then retry or switch provider/model in Setup.',
+      };
+  }
+}
+
+function classifyProviderError(err, context = {}) {
+  if (err?.providerError && typeof err.providerError === 'object') return err.providerError;
+  const status = extractStatus(err);
+  const rawMessage = buildRawMessage(err);
+  const lower = rawMessage.toLowerCase();
+  const type = context.type || classifyType(status, lower);
+  const copy = messageForType(type);
+  const provider = context.provider || err?.provider || err?.providerType || null;
+  const model = context.model || err?.model || null;
+  const providerName = providerLabel(provider);
+  const modelSuffix = model ? ` (${model})` : '';
+  const retryAfter = extractRetryAfter(err);
+  const retrySuffix = retryAfter ? ` Retry after ${retryAfter}.` : '';
+  return {
+    code: 'AI_PROVIDER_ERROR',
+    type,
+    severity: type === 'context_window' ? 'warning' : 'error',
+    title: copy.title,
+    message: copy.body,
+    userMessage: `${providerName}${modelSuffix}: ${copy.body}${retrySuffix}`,
+    rawMessage,
+    status,
+    provider,
+    model,
+    retryAfter,
+    actionLabel: 'Open Setup',
+    actionUrl: '/setup.html',
+    createdAt: new Date().toISOString(),
+  };
+}
+
+function decorateProviderError(err, context = {}) {
+  const base = err instanceof Error ? err : new Error(String(err || 'AI provider failed'));
+  base.providerError = classifyProviderError(base, context);
+  base.code = 'AI_PROVIDER_ERROR';
+  if (base.providerError.status && !base.status) base.status = base.providerError.status;
+  return base;
+}
+
+function unavailableProviderError(providers = [], context = {}) {
+  const details = providers
+    .map((provider) => {
+      const label = provider.providerType || provider.providerId || 'provider';
+      return `${label}: ${provider.lastError || provider.status || 'unhealthy'}`;
+    })
+    .join('\n');
+  const err = new Error(details || 'No configured AI provider is currently available');
+  err.status = 503;
+  return decorateProviderError(err, {
+    ...context,
+    type: 'provider_unavailable_local',
+    provider: context.provider || providers[0]?.providerType || null,
+  });
+}
+
+function toApiPayload(err, context = {}) {
+  const providerError = classifyProviderError(err, context);
+  return {
+    error: providerError.title,
+    message: providerError.userMessage,
+    code: 'AI_PROVIDER_ERROR',
+    providerError,
+  };
+}
+
+function recordProviderFailureAlert(providerError, brain) {
+  if (!providerError) return { alerted: false };
+  try {
+    const planner = require('../skills/skill-planner');
+    planner.addServiceAlert({
+      service: 'ai_provider',
+      type: `ai_provider:${providerError.provider || 'default'}:${providerError.type}`,
+      title: providerError.title,
+      severity: providerError.severity || 'error',
+      provider: providerError.provider || null,
+      model: providerError.model || null,
+      message: `${providerError.title}: ${providerError.userMessage}`,
+      action_url: providerError.actionUrl || '/setup.html',
+      provider_error: providerError,
+    });
+    return { alerted: true };
+  } catch (err) {
+    return { alerted: false, error: err.message };
+  }
+}
+
+module.exports = {
+  classifyProviderError,
+  decorateProviderError,
+  providerLabel,
+  recordProviderFailureAlert,
+  redactSecrets,
+  toApiPayload,
+  unavailableProviderError,
+};

package/template/wall-e/llm/tool-adapter.js

@@ -1,6 +1,7 @@
 'use strict';
 
 let geminiToolCallSeq = 0;
+let openAIToolCallSeq = 0;
 
 // ============================================================
 // Tool definition converters
@@ -63,10 +64,19 @@ function toAnthropic(tools) {
  */
 function messagesToOpenAI(messages) {
   const out = [];
+  const pendingToolCallIds = [];
+
   for (const msg of messages) {
     // Simple string content — pass through
     if (typeof msg.content === 'string') {
-      out.push({ role: msg.role, content: msg.content });
+      const converted = { role: msg.role, content: msg.content };
+      if (msg.role === 'assistant' && Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0) {
+        converted.tool_calls = normalizeOpenAIToolCalls(msg.tool_calls, pendingToolCallIds);
+      }
+      if (msg.role === 'tool') {
+        converted.tool_call_id = consumeToolCallId(msg.tool_call_id, pendingToolCallIds);
+      }
+      out.push(converted);
       continue;
     }
 
@@ -82,7 +92,7 @@ function messagesToOpenAI(messages) {
       for (const tr of toolResults) {
         out.push({
           role: 'tool',
-          tool_call_id: tr.tool_use_id,
+          tool_call_id: consumeToolCallId(tr.tool_use_id || tr.id || tr.toolCallId, pendingToolCallIds),
           content: typeof tr.content === 'string' ? tr.content : JSON.stringify(tr.content),
         });
       }
@@ -138,14 +148,18 @@ function messagesToOpenAI(messages) {
     }
 
     if (toolUses.length > 0) {
-      converted.tool_calls = toolUses.map((tu) => ({
-        id: tu.id,
-        type: 'function',
-        function: {
-          name: tu.name,
-          arguments: JSON.stringify(tu.input),
-        },
-      }));
+      converted.tool_calls = toolUses.map((tu, index) => {
+        const id = tu.id || tu.tool_use_id || tu.toolCallId || synthesizeOpenAIToolCallId(index);
+        pendingToolCallIds.push(id);
+        return {
+          id,
+          type: 'function',
+          function: {
+            name: tu.name,
+            arguments: JSON.stringify(tu.input ?? {}),
+          },
+        };
+      });
     }
 
     if (reasoningParts.length > 0) {
@@ -191,8 +205,8 @@ function responseFromOpenAI(resp) {
 
   return {
     content: msg.content || null,
-    toolCalls: (msg.tool_calls || []).map((tc) => ({
-      id: tc.id,
+    toolCalls: (msg.tool_calls || []).map((tc, index) => ({
+      id: tc.id || synthesizeOpenAIToolCallId(index),
       name: tc.function.name,
       input: safeJsonParse(tc.function.arguments),
     })),
@@ -242,6 +256,28 @@ function safeJsonParse(str) {
   }
 }
 
+function synthesizeOpenAIToolCallId(index = 0) {
+  openAIToolCallSeq += 1;
+  return `call_walle_${openAIToolCallSeq}_${index}`;
+}
+
+function normalizeOpenAIToolCalls(toolCalls = [], pendingToolCallIds = []) {
+  return toolCalls.map((tc, index) => {
+    const id = tc.id || synthesizeOpenAIToolCallId(index);
+    pendingToolCallIds.push(id);
+    return { ...tc, id };
+  });
+}
+
+function consumeToolCallId(explicitId, pendingToolCallIds = []) {
+  if (explicitId) {
+    const pendingIndex = pendingToolCallIds.indexOf(explicitId);
+    if (pendingIndex >= 0) pendingToolCallIds.splice(pendingIndex, 1);
+    return explicitId;
+  }
+  return pendingToolCallIds.shift() || synthesizeOpenAIToolCallId(0);
+}
+
 module.exports = {
   toOpenAI,
   toGemini,

package/template/wall-e/loops/boot.js

@@ -84,7 +84,8 @@ async function runBootCheck(opts = {}) {
   } catch (e) {
     return { status: 'failed', reason: 'no-client', error: e.message };
   }
-  const model = opts.model || process.env.WALLE_MODEL || 'claude-haiku-4-5-20251001';
+  const { getDefaultModel, resolveCompatibleModel } = require('../llm/client');
+  const model = resolveCompatibleModel(opts.model || process.env.WALLE_MODEL || getDefaultModel(), provider.type);
 
   const prompt = _buildBootPrompt(file.content);
   const controller = new AbortController();

package/template/wall-e/loops/initiative.js

@@ -3,7 +3,7 @@
 const brain = require('../brain');
 const { buildStateSnapshot, isStateEmpty, formatSnapshot } = require('../context/state-snapshot');
 const { canActAutonomously, getDomainConfidence } = require('../decision/confidence');
-const { getDefaultClient } = require('../llm/client');
+const { getDefaultClient, getDefaultModel, resolveCompatibleModel } = require('../llm/client');
 const { v4: uuidv4 } = require('uuid');
 const { buildDisciplineHeader } = require('./loop-prompt-discipline');
 const { augmentSystemPrompt } = require('./loop-directives');
@@ -287,7 +287,7 @@ async function runInitiativeLoop(opts = {}) {
 
   // Call Claude with a focused prompt
   const provider = opts.client || getDefaultClient();
-  const model = opts.model || process.env.WALLE_MODEL || 'claude-haiku-4-5-20251001';
+  const model = resolveCompatibleModel(opts.model || process.env.WALLE_MODEL || getDefaultModel(), provider.type);
 
   const controller = new AbortController();
   const timeout = setTimeout(() => controller.abort(), 30000);

package/template/wall-e/loops/tasks.js

@@ -293,53 +293,14 @@ async function executeSkill(taskId, task) {
   appendLog(taskId, `Skill: ${skill.name} v${skill.version} (${skill.execution})`);
 
   if (skill.execution === 'script') {
-    // Resolve entry point relative to the skill directory
-    const entryPath = path.resolve(skill.dir, skill.entry || 'run.js');
-    if (!require('fs').existsSync(entryPath)) {
-      throw new Error(`Skill entry point not found: ${entryPath}`);
-    }
-
-    // Build the shell command: node <entry> <args...>
-    const args = [...(skill.args || [])];
-
-    // Merge task-level skill_config with skill defaults
-    const skillConfig = {};
-    if (skill.config) {
-      for (const [k, v] of Object.entries(skill.config)) {
-        if (v && typeof v === 'object' && v.default !== undefined) {
-          skillConfig[k] = v.default;
-        }
-      }
-    }
-    // Task overrides
-    let taskConfig = {};
-    if (task.skill_config) {
-      try {
-        taskConfig = typeof task.skill_config === 'string'
-          ? JSON.parse(task.skill_config)
-          : task.skill_config;
-      } catch {}
-    }
-    Object.assign(skillConfig, taskConfig);
-
-    // For slack-backfill: pass mode/month as CLI args if configured
-    if (skillConfig.mode && !args.includes(skillConfig.mode)) {
-      // Only add mode as arg if the script expects it as argv[2]
-      // (slack-backfill uses process.argv[2] as mode)
-      if (skill.name === 'slack-backfill') {
-        args.push(skillConfig.mode);
-        if (skillConfig.month) args.push(skillConfig.month);
-      }
-    }
-
-    const scriptCmd = `node ${entryPath} ${args.join(' ')}`.trim();
-    appendLog(taskId, `Running: ${scriptCmd}`);
-
-    // Pass config as env var + checkpoint support
-    return executeScript(taskId, scriptCmd, task.checkpoint, {
-      WALL_E_SKILL_CONFIG: JSON.stringify(skillConfig),
-      WALL_E_SKILL_DIR: skill.dir,
-      WALL_E_SRC_DIR: WALL_E_DIR,
+    const { runScriptSkill } = require('../skills/script-skill-runner');
+    return runScriptSkill(skill, task, {
+      log: line => appendLog(taskId, line),
+      onCheckpoint: checkpoint => brain.updateTask(taskId, { checkpoint }),
+      onProcess: child => taskProcesses.set(taskId, child),
+      onClose: child => {
+        if (taskProcesses.get(taskId) === child) taskProcesses.delete(taskId);
+      },
     });
   }
 

package/template/wall-e/loops/workspace-prompts.js

@@ -151,6 +151,25 @@ function composePersonaBlock() {
   return sections.length ? sections.join('\n\n') : '';
 }
 
+function getWorkspacePersonaSections({ recipient = 'agent' } = {}) {
+  const sections = [];
+  for (const name of ['IDENTITY', 'SOUL', 'USER', 'TOOLS', 'AGENTS']) {
+    const content = readWorkspacePrompt(name);
+    if (!content || isContentEffectivelyEmpty(content)) continue;
+    sections.push({
+      id: `workspace-${name.toLowerCase()}`,
+      source: `workspace:${name}.md`,
+      content: content.trim(),
+      recipient,
+      cacheable: true,
+      visibility: 'llm',
+      mutableByHooks: true,
+      redactionPolicy: name === 'USER' ? 'standard' : 'secrets',
+    });
+  }
+  return sections;
+}
+
 /** Test helper. */
 function clearWorkspacePromptsCache() {
   _cache.clear();
@@ -204,6 +223,7 @@ module.exports = {
   readWorkspacePrompt,
   isContentEffectivelyEmpty,
   composePersonaBlock,
+  getWorkspacePersonaSections,
   initWorkspaceFromTemplates,
   clearWorkspacePromptsCache,
   _resolveWorkspacePath,