create-walle 0.9.21 → 0.9.23

package/template/wall-e/memory/ctm-context-client.js

@@ -2,7 +2,7 @@
 
 const ctmSessionContext = require('./ctm-session-context');
 
-const DEFAULT_TIMEOUT_MS = 700;
+const DEFAULT_TIMEOUT_MS = 2500;
 const DEFAULT_COOLDOWN_MS = 15000;
 
 let apiFailureUntil = 0;
@@ -11,16 +11,18 @@ let lastApiFailure = null;
 function resolveApiBaseUrl(env = process.env) {
   const explicit = env.CTM_SESSION_MEMORY_API_BASE_URL || env.CTM_API_BASE_URL || env.CTM_BASE_URL;
   if (explicit) return explicit.replace(/\/+$/, '');
-  if (env.WALLE_CTM_API === '1' && (env.CTM_PORT || env.DEV_CTM_PORT)) {
-    return `http://127.0.0.1:${env.CTM_PORT || env.DEV_CTM_PORT}`;
-  }
-  return '';
+  if (env.WALLE_CTM_API === '0') return '';
+  return `http://127.0.0.1:${env.CTM_PORT || env.DEV_CTM_PORT || '3456'}`;
 }
 
 function apiDisabled(env = process.env) {
   return env.WALLE_CTM_API_DISABLED === '1' || env.CTM_SESSION_MEMORY_API === '0';
 }
 
+function directFallbackAllowed(env = process.env, options = {}) {
+  return options.allowDirectFallback === true || env.WALLE_CTM_DIRECT_READ_FALLBACK === '1';
+}
+
 async function getHealth(options = {}) {
   return apiFirst({
     path: '/api/ctm/session-memory/health',
@@ -61,6 +63,24 @@ async function getSessionContext(args = {}, options = {}) {
   });
 }
 
+async function getRemoteAccessStatus(args = {}, options = {}) {
+  return apiFirst({
+    path: '/api/setup/network',
+    fallback: () => ({
+      ok: false,
+      source: 'ctm-api',
+      authority: 'ctm',
+      reason: 'ctm_api_required',
+      remote_access: null,
+    }),
+    options: {
+      ...options,
+      preferApi: args.prefer_api !== false && options.preferApi !== false,
+      timeoutMs: options.timeoutMs ?? 6000,
+    },
+  });
+}
+
 async function buildContextPack(args = {}, options = {}) {
   return apiFirst({
     path: '/api/ctm/session-memory/context-pack',
@@ -112,21 +132,38 @@ async function backfillMessageIndex(args = {}, options = {}) {
 async function apiFirst({ path, method = 'GET', body, fallback, options = {} }) {
   const env = options.env || process.env;
   const preferApi = options.preferApi !== false;
-  const fallbackResult = () => annotateFallback(fallback(), {
-    attempted: false,
-    skipped: true,
-    reason: apiDisabled(env) ? 'api_disabled' : 'api_base_url_missing',
-  });
+  const fallbackResult = (apiTransport) => {
+    if (directFallbackAllowed(env, options)) return annotateFallback(fallback(), apiTransport);
+    return {
+      ok: false,
+      source: 'ctm-api',
+      authority: 'ctm',
+      reason: 'ctm_api_required',
+      api_transport: apiTransport,
+    };
+  };
 
-  if (!preferApi || apiDisabled(env)) return fallbackResult();
+  if (!preferApi || apiDisabled(env)) {
+    return fallbackResult({
+      attempted: false,
+      skipped: true,
+      reason: apiDisabled(env) ? 'api_disabled' : 'api_not_preferred',
+    });
+  }
 
   const baseUrl = resolveApiBaseUrl(env);
-  if (!baseUrl) return fallbackResult();
+  if (!baseUrl) {
+    return fallbackResult({
+      attempted: false,
+      skipped: true,
+      reason: 'api_base_url_missing',
+    });
+  }
 
   const now = Date.now();
   const cooldownMs = options.cooldownMs ?? DEFAULT_COOLDOWN_MS;
   if (cooldownMs > 0 && apiFailureUntil > now) {
-    return annotateFallback(fallback(), {
+    return fallbackResult({
       attempted: false,
       skipped: true,
       reason: 'api_cooldown',
@@ -154,7 +191,7 @@ async function apiFirst({ path, method = 'GET', body, fallback, options = {} })
   } catch (err) {
     lastApiFailure = err.message;
     apiFailureUntil = Date.now() + cooldownMs;
-    return annotateFallback(fallback(), {
+    return fallbackResult({
       attempted: true,
       ok: false,
       base_url: baseUrl,
@@ -224,6 +261,7 @@ module.exports = {
   getHealth,
   searchSessions,
   getSessionContext,
+  getRemoteAccessStatus,
   buildContextPack,
   backfillMessageIndex,
   resetApiState,

package/template/wall-e/memory/ctm-operational-context.js

@@ -0,0 +1,237 @@
+'use strict';
+
+const ctmContextClient = require('./ctm-context-client');
+
+const CTM_RE = /\b(?:ctm|claude task manager|task manager|wall-?e|walle)\b/i;
+const REMOTE_RE = /\b(?:mobile|phone|remote|url|link|primary|dev\s*tunnel|devtunnel|devtunnels\.ms|tunnel|tailscale|cloudflare|pair(?:ing)?|\/m\/|setup\/network)\b/i;
+const SESSION_MEMORY_RE = /\b(?:ctm\s+session\s+memory|session\s+memory|session\s+logs?|coding\s+sessions?|agent\s+sessions?)\b/i;
+
+function classifyCtmOperationalQuery(query, opts = {}) {
+  const text = `${query || ''}\n${opts.context || ''}`;
+  const matched = [];
+  const add = (name, re) => {
+    const hit = re.test(text);
+    if (hit) matched.push(name);
+    return hit;
+  };
+  const hasCtm = add('ctm', CTM_RE);
+  const hasRemote = add('remote_access', REMOTE_RE);
+  const hasSessionMemory = add('session_memory', SESSION_MEMORY_RE);
+  const required = (hasCtm && hasRemote) || (hasCtm && hasSessionMemory);
+  return {
+    required,
+    matched,
+    reason: required
+      ? 'The request asks for CTM operational or session-memory context and should not be answered from generic long-term memory.'
+      : 'No strong CTM operational-context signal.',
+  };
+}
+
+function buildSessionSearchQuery(query) {
+  const base = String(query || '').trim();
+  const boosters = 'CTM primary mobile phone URL mobile_url devtunnels.ms /m/ Microsoft dev tunnel current working phone URL';
+  return base ? `${base} ${boosters}` : boosters;
+}
+
+function firstString(...values) {
+  for (const value of values) {
+    const text = String(value || '').trim();
+    if (text) return text;
+  }
+  return '';
+}
+
+function summarizeRemoteAccess(status = {}) {
+  const microsoft = status.microsoft_dev_tunnel || {};
+  const managed = microsoft.managed_tunnel || {};
+  const tailscale = status.tailscale || {};
+  const cloudflare = status.cloudflare_automation || {};
+  const bestMobileUrl = firstString(
+    managed.running ? managed.mobile_url : '',
+    microsoft.mobile_url,
+    tailscale.mobile_url,
+    cloudflare.mobile_url
+  );
+  return {
+    ok: Boolean(status && typeof status === 'object' && !status.reason),
+    port: status.port || '',
+    current_origin: status.current_origin || '',
+    allowed_origins: Array.isArray(status.allowed_origins) ? status.allowed_origins.slice(-5) : [],
+    best_mobile_url: bestMobileUrl,
+    microsoft_dev_tunnel: {
+      available: Boolean(microsoft.available),
+      signed_in: Boolean(microsoft.signed_in),
+      origin: microsoft.origin || managed.origin || '',
+      mobile_url: microsoft.mobile_url || managed.mobile_url || '',
+      tunnel_id: microsoft.tunnel_id || managed.tunnel_id || '',
+      running: Boolean(managed.running),
+      access_mode: managed.access_mode || managed.access?.mode || '',
+      anonymous_connect: Boolean(managed.access?.anonymous_connect),
+      checked_at: managed.last_access_check_at || managed.access?.checked_at || '',
+    },
+    tailscale: {
+      available: Boolean(tailscale.available),
+      origin: tailscale.origin || '',
+      mobile_url: tailscale.mobile_url || '',
+    },
+    cloudflare: {
+      available: Boolean(cloudflare.available),
+      configured: Boolean(cloudflare.managed_tunnel?.configured),
+      running: Boolean(cloudflare.managed_tunnel?.running),
+      mobile_url: cloudflare.mobile_url || cloudflare.managed_tunnel?.mobile_url || '',
+    },
+  };
+}
+
+function summarizeSessionResult(item = {}) {
+  return {
+    session_id: item.session_id || item.ctm_session_id || '',
+    agent_session_id: item.agent_session_id || '',
+    title: item.title || '',
+    provider: item.provider || '',
+    model: item.model || '',
+    branch: item.branch || '',
+    timestamp: item.timestamp || item.created_at || '',
+    message_index: item.message_index,
+    snippet: String(item.snippet || item.content || '').slice(0, 1200),
+  };
+}
+
+function sourceOk(result) {
+  return Boolean(result && (result.ok || result.api_transport?.ok || result.port || result.current_origin || Array.isArray(result.results)));
+}
+
+async function lookupCtmOperationalContext(args = {}, options = {}) {
+  const query = String(args.query || '').trim();
+  const classification = classifyCtmOperationalQuery(query, { context: args.context });
+  if (!classification.required && !args.force) {
+    return {
+      required: false,
+      ok: true,
+      classification,
+      query,
+      remote_access: null,
+      session_results: [],
+      sources: {
+        remote_access: { searched: false, ok: true, reason: 'not_required' },
+        ctm_sessions: { searched: false, ok: true, reason: 'not_required' },
+      },
+      context_text: '',
+    };
+  }
+
+  const timeoutMs = options.timeoutMs ?? args.timeout_ms ?? 6000;
+  const cooldownMs = options.cooldownMs ?? args.cooldown_ms ?? 0;
+  const limit = Math.max(1, Math.min(Number(args.limit || 5), 10));
+  const clientOptions = {
+    ...options,
+    timeoutMs,
+    cooldownMs,
+  };
+
+  const [remoteStatus, sessionSearch] = await Promise.all([
+    ctmContextClient.getRemoteAccessStatus({}, clientOptions).catch((err) => ({
+      ok: false,
+      source: 'ctm-api',
+      reason: err.message,
+    })),
+    ctmContextClient.searchSessions({
+      query: buildSessionSearchQuery(query),
+      limit,
+      prefer_api: args.prefer_api,
+    }, clientOptions).catch((err) => ({
+      ok: false,
+      source: 'ctm-api',
+      results: [],
+      reason: err.message,
+    })),
+  ]);
+
+  const remoteOk = sourceOk(remoteStatus) && !remoteStatus.reason;
+  const sessionOk = Boolean(sessionSearch?.ok);
+  const sessionResults = (sessionSearch?.results || []).slice(0, limit).map(summarizeSessionResult);
+  const remoteAccess = remoteOk ? summarizeRemoteAccess(remoteStatus) : null;
+  const ok = Boolean(remoteAccess?.best_mobile_url || sessionResults.length > 0);
+  const result = {
+    required: true,
+    ok,
+    classification,
+    query,
+    remote_access: remoteAccess,
+    session_results: sessionResults,
+    sources: {
+      remote_access: {
+        searched: true,
+        ok: remoteOk,
+        source: remoteStatus?.source || 'ctm-api',
+        reason: remoteStatus?.reason || '',
+        api_transport: remoteStatus?.api_transport || null,
+      },
+      ctm_sessions: {
+        searched: true,
+        ok: sessionOk,
+        source: sessionSearch?.source || '',
+        backend_source: sessionSearch?.backend_source || '',
+        reason: sessionSearch?.reason || '',
+        api_transport: sessionSearch?.api_transport || null,
+        count: sessionResults.length,
+      },
+    },
+    must_not_guess: !ok,
+  };
+  result.context_text = renderCtmOperationalContext(result);
+  return result;
+}
+
+function renderCtmOperationalContext(context = {}) {
+  if (!context.required) return '';
+  const lines = [
+    'CTM operational context (authoritative for CTM/mobile/session-memory questions):',
+  ];
+  const remote = context.remote_access || {};
+  if (remote.best_mobile_url) {
+    lines.push(`- Current best phone URL: ${remote.best_mobile_url}`);
+  }
+  if (remote.current_origin) {
+    lines.push(`- Current CTM origin: ${remote.current_origin}`);
+  }
+  if (remote.microsoft_dev_tunnel?.mobile_url) {
+    const ms = remote.microsoft_dev_tunnel;
+    const state = ms.running ? 'running' : 'not running';
+    const access = ms.access_mode ? `, access=${ms.access_mode}` : '';
+    lines.push(`- Microsoft Dev Tunnel: ${ms.mobile_url} (${state}${access})`);
+  }
+  if (remote.tailscale?.mobile_url) {
+    lines.push(`- Tailscale phone URL: ${remote.tailscale.mobile_url}`);
+  }
+  if (Array.isArray(remote.allowed_origins) && remote.allowed_origins.length) {
+    lines.push(`- Allowed remote origins: ${remote.allowed_origins.join(', ')}`);
+  }
+
+  const sessionResults = context.session_results || [];
+  if (sessionResults.length) {
+    lines.push('- CTM session-memory evidence:');
+    sessionResults.forEach((item, index) => {
+      const label = [item.timestamp, item.title, item.session_id].filter(Boolean).join(' | ');
+      lines.push(`  ${index + 1}. ${label}`);
+      if (item.snippet) lines.push(`     ${item.snippet}`);
+    });
+  }
+
+  if (!remote.best_mobile_url && sessionResults.length === 0) {
+    lines.push('- No verified CTM remote URL or session-memory evidence was found.');
+    lines.push('- Do not guess from generic project memories, DDEV hosts, localhost, or local IP heuristics.');
+  } else {
+    lines.push('- Prefer current CTM setup/network status over older session-memory snippets. Use snippets only as last-known history.');
+    lines.push('- Do not use unrelated DDEV/project memories as CTM primary remote-access answers.');
+  }
+  return lines.join('\n');
+}
+
+module.exports = {
+  classifyCtmOperationalQuery,
+  buildSessionSearchQuery,
+  lookupCtmOperationalContext,
+  renderCtmOperationalContext,
+  summarizeRemoteAccess,
+};

package/template/wall-e/memory/ctm-prompt-executions-client.js

@@ -0,0 +1,128 @@
+'use strict';
+
+const { resolveApiBaseUrl } = require('./ctm-context-client');
+
+const DEFAULT_TIMEOUT_MS = 1000;
+
+function apiDisabled(env = process.env) {
+  return env.WALLE_CTM_API_DISABLED === '1' || env.CTM_SESSION_MEMORY_API === '0';
+}
+
+async function requestCtmJson(path, options = {}) {
+  const env = options.env || process.env;
+  if (apiDisabled(env)) {
+    const err = new Error('CTM API disabled');
+    err.code = 'ctm_api_disabled';
+    throw err;
+  }
+  const baseUrl = resolveApiBaseUrl(env);
+  if (!baseUrl) {
+    const err = new Error('CTM API base URL missing');
+    err.code = 'ctm_api_base_missing';
+    throw err;
+  }
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), options.timeoutMs || DEFAULT_TIMEOUT_MS);
+  try {
+    const headers = { Accept: 'application/json' };
+    const token = env.CTM_TOKEN || env.WALLE_CTM_TOKEN || env.CTM_API_TOKEN;
+    if (token) headers.Authorization = `Bearer ${token}`;
+    const response = await fetch(`${baseUrl}${path}`, {
+      method: 'GET',
+      headers,
+      signal: controller.signal,
+    });
+    const text = await response.text();
+    const json = text ? JSON.parse(text) : {};
+    if (!response.ok) {
+      const err = new Error(json?.error || json?.reason || `ctm_api_http_${response.status}`);
+      err.status = response.status;
+      throw err;
+    }
+    return json;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+async function listPromptExecutions(options = {}) {
+  const params = new URLSearchParams();
+  params.set('limit', String(Math.max(1, Math.min(Number(options.limit) || 1000, 10000))));
+  params.set('order', options.order === 'asc' ? 'asc' : 'desc');
+  if (options.since) params.set('after', String(options.since));
+  if (options.role) params.set('role', String(options.role));
+  const json = await requestCtmJson(`/api/prompt-executions?${params.toString()}`, options);
+  return Array.isArray(json.executions) ? json.executions : [];
+}
+
+async function getPromptExecutionStats(options = {}) {
+  return requestCtmJson('/api/prompt-executions/stats', options);
+}
+
+function pairPromptExecutions(rows, options = {}) {
+  const bySession = new Map();
+  for (const row of rows || []) {
+    const sessionId = row.session_id || '';
+    if (!sessionId) continue;
+    if (!bySession.has(sessionId)) bySession.set(sessionId, []);
+    bySession.get(sessionId).push(row);
+  }
+
+  const pairs = [];
+  for (const [sessionId, sessionRows] of bySession.entries()) {
+    sessionRows.sort((a, b) => Number(a.message_index || 0) - Number(b.message_index || 0));
+    const userCount = sessionRows.filter((row) => row.role === 'user').length;
+    if (options.singleTurnOnly && userCount !== 1) continue;
+    const byIndex = new Map(sessionRows.map((row) => [Number(row.message_index || 0), row]));
+    for (const row of sessionRows) {
+      if (row.role !== 'user') continue;
+      const assistant = byIndex.get(Number(row.message_index || 0) + 1);
+      if (!assistant || assistant.role !== 'assistant') continue;
+      const prompt = row.message_text || '';
+      const response = assistant.message_text || '';
+      if (prompt.length < 20 || response.length < 20) continue;
+      pairs.push({
+        session_id: sessionId,
+        prompt,
+        response,
+        executed_at: row.executed_at,
+        project_path: row.project_path,
+        tool_uses: assistant.tool_uses,
+      });
+    }
+  }
+  pairs.sort((a, b) => String(a.executed_at || '').localeCompare(String(b.executed_at || '')));
+  return options.limit ? pairs.slice(0, options.limit) : pairs;
+}
+
+function groupPromptExecutionsBySession(rows, options = {}) {
+  const sessions = new Map();
+  for (const row of rows || []) {
+    const sessionId = row.session_id || '';
+    if (!sessionId) continue;
+    if (!sessions.has(sessionId)) sessions.set(sessionId, []);
+    sessions.get(sessionId).push(row);
+  }
+  const out = [];
+  for (const [sessionId, messages] of sessions.entries()) {
+    messages.sort((a, b) => Number(a.message_index || 0) - Number(b.message_index || 0));
+    const userCount = messages.filter((row) => row.role === 'user').length;
+    if (options.multiTurnOnly && userCount < 2) continue;
+    out.push({
+      session_id: sessionId,
+      started_at: messages[0]?.executed_at || '',
+      msg_count: messages.length,
+      messages,
+    });
+  }
+  out.sort((a, b) => String(a.started_at || '').localeCompare(String(b.started_at || '')));
+  return options.limit ? out.slice(0, options.limit) : out;
+}
+
+module.exports = {
+  getPromptExecutionStats,
+  groupPromptExecutionsBySession,
+  listPromptExecutions,
+  pairPromptExecutions,
+  requestCtmJson,
+};