create-walle 0.9.13 → 0.9.15

package/template/claude-task-manager/git-utils.js

@@ -2,6 +2,19 @@
 const { execFile } = require('child_process');
 const path = require('path');
 
+function _worktreeNamespace(options) {
+  const raw = typeof options === 'string'
+    ? options
+    : (options && (options.namespace || options.agentType || options.owner)) || '';
+  const normalized = String(raw || '').toLowerCase();
+  return normalized === 'walle' || normalized === 'wall-e' ? 'walle' : 'claude';
+}
+
+function _worktreeParentDir(cwd, options) {
+  const namespace = _worktreeNamespace(options);
+  return path.join(cwd, namespace === 'walle' ? '.walle' : '.claude', 'worktrees');
+}
+
 // Run a git command in a given project directory
 function git(cwd, args, maxBuffer = 1024 * 1024 * 5) {
   return new Promise((resolve, reject) => {
@@ -301,10 +314,15 @@ async function _branchExists(cwd, branch) {
 //     worktree to it (no -b).
 //   - Path exists on disk but unregistered, or path/branch is in use by
 //     a different mapping → auto-suffix the name (-2, -3, …) up to -20.
-async function createWorktree(cwd, name, baseBranch) {
+async function createWorktree(cwd, name, baseBranch, options) {
   const fs = require('fs');
+  if (baseBranch && typeof baseBranch === 'object') {
+    options = baseBranch;
+    baseBranch = undefined;
+  }
   const base = baseBranch || 'HEAD';
-  const parentDir = path.join(cwd, '.claude', 'worktrees');
+  const namespace = _worktreeNamespace(options);
+  const parentDir = _worktreeParentDir(cwd, namespace);
   fs.mkdirSync(parentDir, { recursive: true });
 
   const worktrees = await listWorktrees(cwd).catch(() => []);
@@ -315,7 +333,7 @@ async function createWorktree(cwd, name, baseBranch) {
   const initialReal = _real(initialPath);
   const existingAtPath = worktrees.find(w => _real(w.path) === initialReal);
   if (existingAtPath && existingAtPath.branch === name) {
-    return { path: existingAtPath.path, branch: existingAtPath.branch, reused: true };
+    return { path: existingAtPath.path, branch: existingAtPath.branch, reused: true, namespace };
   }
 
   // Attach to existing branch (no clash on path). Common after a worktree
@@ -323,7 +341,7 @@ async function createWorktree(cwd, name, baseBranch) {
   if (!existingAtPath && !fs.existsSync(initialPath) && await _branchExists(cwd, name)
       && !worktrees.some(w => w.branch === name)) {
     await git(cwd, ['worktree', 'add', initialPath, name]);
-    return { path: initialPath, branch: name, attached: true };
+    return { path: initialPath, branch: name, attached: true, namespace };
   }
 
   // Pick a free (path, branch) pair. Suffix until both slots are clear.
@@ -339,6 +357,7 @@ async function createWorktree(cwd, name, baseBranch) {
     return {
       path: candidatePath,
       branch: candidateName,
+      namespace,
       ...(candidateName !== name ? { suffixed: true, requestedName: name } : {}),
     };
   }
@@ -437,7 +456,7 @@ function _realpath(p) {
 //
 // listRichWorktrees(cwd, mainBranch) returns each worktree augmented with:
 //   - state: 'primary'|'clean'|'ahead'|'behind'|'diverged'|'dirty'|'detached'|'ghost'
-//   - isCanonical: path lives under <repo>/.claude/worktrees/<name>
+//   - isCanonical: path lives under an agent-owned <repo>/.claude|.walle/worktrees/<name>
 //   - isGhost: path contains /~/ corruption OR path doesn't exist on disk
 //   - ahead/behind vs mainBranch
 //   - dirtyFiles: count of modified+untracked
@@ -457,6 +476,106 @@ async function _gitSafe(cwd, args, timeoutMs = 5000) {
   });
 }
 
+function _parseGitHubRemoteUrl(remoteUrl) {
+  const raw = String(remoteUrl || '').trim();
+  if (!raw) return null;
+
+  let host = 'github.com';
+  let owner = '';
+  let repo = '';
+  let match = raw.match(/^git@([^:]+):([^/]+)\/(.+)$/);
+  if (match) {
+    host = match[1];
+    owner = match[2];
+    repo = match[3];
+  } else {
+    match = raw.match(/^ssh:\/\/(?:[^@/]+@)?([^/]+)\/([^/]+)\/(.+)$/);
+    if (match) {
+      host = match[1];
+      owner = match[2];
+      repo = match[3];
+    } else {
+      match = raw.match(/^https?:\/\/([^/]+)\/([^/]+)\/(.+)$/);
+      if (!match) return null;
+      host = match[1];
+      owner = match[2];
+      repo = match[3];
+    }
+  }
+
+  repo = repo.replace(/(?:\.git)?\/?$/, '');
+  if (!host || !owner || !repo || repo.includes('/')) return null;
+  const nameWithOwner = `${owner}/${repo}`;
+  return {
+    host,
+    owner,
+    repo,
+    nameWithOwner,
+    ghRepo: host === 'github.com' ? nameWithOwner : `${host}/${nameWithOwner}`,
+  };
+}
+
+async function _githubRemoteSpec(cwd, remoteName) {
+  if (!remoteName) return null;
+  const urls = [
+    await _gitSafe(cwd, ['remote', 'get-url', remoteName]),
+    await _gitSafe(cwd, ['remote', 'get-url', '--push', remoteName]),
+  ].filter(Boolean);
+  for (const url of urls) {
+    const spec = _parseGitHubRemoteUrl(url);
+    if (spec) return { ...spec, remote: remoteName, url };
+  }
+  return null;
+}
+
+async function _selectPrBaseRemote(cwd, base, remoteNames) {
+  const remotes = Array.isArray(remoteNames) ? remoteNames : [];
+  if (remotes.includes('upstream') && await _githubRemoteSpec(cwd, 'upstream')) {
+    return 'upstream';
+  }
+
+  const configured = await _gitSafe(cwd, ['config', '--get', `branch.${base}.remote`]);
+  if (configured && configured !== '.' && remotes.includes(configured)
+      && await _githubRemoteSpec(cwd, configured)) {
+    return configured;
+  }
+
+  if (remotes.includes('origin') && await _githubRemoteSpec(cwd, 'origin')) {
+    return 'origin';
+  }
+
+  for (const remote of remotes) {
+    if (await _githubRemoteSpec(cwd, remote)) return remote;
+  }
+  return null;
+}
+
+async function _buildGhPrCreateArgs(cwd, branchName, opts) {
+  opts = opts || {};
+  const base = opts.base || 'main';
+  const title = opts.title || branchName;
+  const body = opts.body || `Branch \`${branchName}\` opened.`;
+  const remoteOut = await _gitSafe(cwd, ['remote']);
+  const remoteNames = remoteOut ? remoteOut.split('\n').map(s => s.trim()).filter(Boolean) : [];
+  const pushRemote = remoteNames.includes('origin') ? 'origin' : remoteNames[0];
+  const baseRemote = await _selectPrBaseRemote(cwd, base, remoteNames);
+  const baseSpec = await _githubRemoteSpec(cwd, baseRemote);
+  const pushSpec = await _githubRemoteSpec(cwd, pushRemote);
+
+  let head = branchName;
+  if (baseSpec && pushSpec
+      && (baseSpec.host !== pushSpec.host
+        || baseSpec.owner !== pushSpec.owner
+        || baseSpec.repo !== pushSpec.repo)) {
+    head = `${pushSpec.owner}:${branchName}`;
+  }
+
+  const args = ['pr', 'create'];
+  if (baseSpec) args.push('--repo', baseSpec.ghRepo);
+  args.push('--base', base, '--head', head, '--title', title, '--body', body);
+  return { args, baseRemote, pushRemote, baseSpec, pushSpec, head };
+}
+
 function _isGhostPath(p) {
   if (!p) return true;
   if (p.includes('/~/')) return true;          // literal-tilde corruption
@@ -465,8 +584,10 @@ function _isGhostPath(p) {
 
 function _isCanonicalPath(repoRoot, p, isMain) {
   if (isMain) return true;
-  const expected = path.join(repoRoot, '.claude', 'worktrees') + path.sep;
-  return p.startsWith(expected);
+  const value = String(p || '');
+  const expectedClaude = path.join(repoRoot, '.claude', 'worktrees') + path.sep;
+  const expectedWalle = path.join(repoRoot, '.walle', 'worktrees') + path.sep;
+  return value.startsWith(expectedClaude) || value.startsWith(expectedWalle);
 }
 
 function _classifyState(wt) {
@@ -949,11 +1070,18 @@ async function pushAndCreatePR(cwd, branchName, opts) {
     body = log ? `## Summary\n\n${log}\n` : `Branch \`${branchName}\` opened.`;
   }
 
-  // gh pr create — use --json to get the URL back, fall back to scraping stdout.
+  // gh pr create. Do not let gh infer the repository from `origin`: in forked
+  // or stale-remote checkouts that can point it at an inaccessible repo.
+  const prCommand = await _buildGhPrCreateArgs(wt.path, branchName, { base, title, body });
   const ghOut = await new Promise((resolve, reject) => {
-    execFile('gh', ['pr', 'create', '--base', base, '--head', branchName, '--title', title, '--body', body],
+    execFile('gh', prCommand.args,
       { cwd: wt.path, timeout: 60000 }, (err, stdout, stderr) => {
-        if (err) return reject(new Error(`gh pr create failed: ${stderr || err.message}`));
+        if (err) {
+          const target = prCommand.baseSpec
+            ? `${prCommand.baseSpec.ghRepo} from ${prCommand.head}`
+            : `the repository inferred by gh from ${wt.path}`;
+          return reject(new Error(`gh pr create failed for ${target}: ${stderr || err.message}`));
+        }
         resolve((stdout || '').trim());
       });
   });
@@ -971,4 +1099,6 @@ module.exports = {
   // Internal helpers exposed for tests
   _classifyState, _buildSummary, _isGhostPath, _isCanonicalPath, STATE_SORT_RANK,
   _classifyMainRemote, _recommendedAction, _syncAllEligibility, _sameWorktreePath,
+  _parseGitHubRemoteUrl, _githubRemoteSpec, _buildGhPrCreateArgs,
+  _worktreeNamespace, _worktreeParentDir,
 };

package/template/claude-task-manager/lib/agent-capabilities.js

@@ -44,7 +44,7 @@ const AGENT_CAPABILITIES = Object.freeze({
     liveStatus: true,
     stateDetector: false,
     structuredTranscript: true,
-    promptNavigation: 'none',
+    promptNavigation: 'chat',
     review: true,
     resume: false,
     resumeSpec: () => null,

package/template/claude-task-manager/lib/agent-presets.js

@@ -101,6 +101,35 @@ function getPreset(presetId) {
   return PRESETS[presetId] || null;
 }
 
+const INHERITED_AGENT_ENV_KEYS = [
+  'CLAUDECODE',
+  'CLAUDE_CODE',
+  'CLAUDE_CODE_ENTRYPOINT',
+  'CLAUDE_CODE_ENABLE_TELEMETRY',
+  'CODEX_THREAD_ID',
+  'CODEX_SESSION_ID',
+  'CODEX_TURN_ID',
+  'CODEX_CI',
+  'CODEX_SANDBOX_NETWORK_DISABLED',
+  'GEMINI_SESSION_ID',
+];
+
+function sanitizeInheritedAgentEnv(env) {
+  if (!env || typeof env !== 'object') return env;
+  for (const key of INHERITED_AGENT_ENV_KEYS) delete env[key];
+  return env;
+}
+
+function buildResourceAttributes(existing, ctmSessionId) {
+  const prior = String(existing || '')
+    .split(',')
+    .map(s => s.trim())
+    .filter(Boolean)
+    .filter(s => !/^ctm\.session_id=/.test(s) && !/^clideck\.session_id=/.test(s));
+  prior.push(`ctm.session_id=${ctmSessionId}`);
+  return prior.join(',');
+}
+
 /**
  * Build the env object to inject at pty.spawn time.
  *   - ctmSessionId: CTM's UUID for the session (goes into OTEL_RESOURCE_ATTRIBUTES)
@@ -109,21 +138,25 @@ function getPreset(presetId) {
  * Returns an object that can be spread into the env option: `env: { ...process.env, ...telemetryEnv }`.
  * Always includes CTM_SESSION_ID and CTM_PORT — hook bins read these from their own env.
  */
-function buildTelemetryEnv(ctmSessionId, cmd, port) {
+function buildTelemetryEnv(ctmSessionId, cmd, port, baseEnv = process.env) {
   const presetId = detectPresetId(cmd);
   const preset = presetId ? PRESETS[presetId] : null;
   const env = {
     CTM_SESSION_ID: ctmSessionId,
     CTM_PORT: String(port),
+    OTEL_RESOURCE_ATTRIBUTES: buildResourceAttributes(baseEnv?.OTEL_RESOURCE_ATTRIBUTES, ctmSessionId),
   };
   if (!preset || !preset.telemetryEnv) return env;
   for (const [k, v] of Object.entries(preset.telemetryEnv)) {
     env[k] = String(v).replace('{{port}}', String(port));
   }
-  // Correlate OTLP log records to the CTM session id
-  const existing = process.env.OTEL_RESOURCE_ATTRIBUTES || '';
-  env.OTEL_RESOURCE_ATTRIBUTES = (existing ? existing + ',' : '') + `ctm.session_id=${ctmSessionId}`;
   return env;
 }
 
-module.exports = { PRESETS, detectPresetId, getPreset, buildTelemetryEnv };
+module.exports = {
+  PRESETS,
+  detectPresetId,
+  getPreset,
+  buildTelemetryEnv,
+  sanitizeInheritedAgentEnv,
+};

package/template/claude-task-manager/lib/codex-terminal-final.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const crypto = require('crypto');
+
+function stripAnsi(text) {
+  return String(text || '')
+    .replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, '')
+    .replace(/\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)/g, '');
+}
+
+function normalizeForTerminalSearch(text) {
+  return stripAnsi(text)
+    .normalize('NFKC')
+    .replace(/[*_`#>~]/g, '')
+    .replace(/[\x00-\x1f\x7f]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .toLowerCase();
+}
+
+function meaningfulLines(text) {
+  return stripAnsi(text)
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter(Boolean);
+}
+
+function markerForFinalText(text) {
+  const lines = meaningfulLines(text);
+  if (lines.length === 0) return '';
+  let candidate = lines.find((line) => normalizeForTerminalSearch(line).length >= 24) || lines[0];
+  if (normalizeForTerminalSearch(candidate).length < 24 && lines.length > 1) {
+    candidate = `${candidate} ${lines[1]}`;
+  }
+  return normalizeForTerminalSearch(candidate).slice(0, 180);
+}
+
+function terminalContainsFinalText(terminalText, finalText) {
+  const marker = markerForFinalText(finalText);
+  if (!marker) return true;
+  return normalizeForTerminalSearch(terminalText).includes(marker);
+}
+
+function fingerprintFinalText(text) {
+  return crypto.createHash('sha1').update(String(text || '')).digest('hex').slice(0, 16);
+}
+
+module.exports = {
+  fingerprintFinalText,
+  markerForFinalText,
+  normalizeForTerminalSearch,
+  terminalContainsFinalText,
+};

package/template/claude-task-manager/lib/ctm-session-context-api.js

@@ -0,0 +1,222 @@
+'use strict';
+
+let ctmSessionContext = null;
+let ctmSessionContextLoadError = null;
+
+function loadCtmSessionContext() {
+  if (ctmSessionContext || ctmSessionContextLoadError) return ctmSessionContext;
+  try {
+    ctmSessionContext = require('../../wall-e/memory/ctm-session-context');
+  } catch (err) {
+    ctmSessionContextLoadError = err;
+  }
+  return ctmSessionContext;
+}
+
+function handleCtmSessionContextApi(req, res, url, { db, dbModule } = {}) {
+  if (!url.pathname.startsWith('/api/ctm/session-memory')) return false;
+
+  const context = loadCtmSessionContext();
+  if (!context) {
+    return respondJson(res, 503, {
+      ok: false,
+      source: 'ctm-api',
+      reason: 'ctm_session_context_unavailable',
+      error: ctmSessionContextLoadError?.message || 'CTM session context module unavailable',
+    });
+  }
+
+  try {
+    if (url.pathname === '/api/ctm/session-memory/health' && req.method === 'GET') {
+      return respondJson(res, 200, asApiResult(context.getCtmDbHealth({ db })));
+    }
+
+    if (url.pathname === '/api/ctm/session-memory/search' && req.method === 'GET') {
+      const query = url.searchParams.get('q') || url.searchParams.get('query') || '';
+      const limit = url.searchParams.get('limit') || undefined;
+      return respondJson(res, 200, asApiResult(context.searchCtmSessions({ query, limit, db })));
+    }
+
+    if (url.pathname === '/api/ctm/session-memory/context' && req.method === 'GET') {
+      return respondJson(res, 200, asApiResult(context.getCtmSessionContext({
+        session_id: url.searchParams.get('session_id') || url.searchParams.get('id') || '',
+        session_ids: parseListParams(url.searchParams, 'session_id', 'session_ids', 'ids'),
+        limit: url.searchParams.get('limit') || undefined,
+        cursor: url.searchParams.get('cursor') || undefined,
+        include_raw: parseBool(url.searchParams.get('include_raw')),
+        dedupe: !parseBool(url.searchParams.get('no_dedupe')),
+        format: url.searchParams.get('format') || 'messages',
+        db,
+      })));
+    }
+
+    if (
+      (url.pathname === '/api/ctm/session-memory/message-index/backfill'
+        || url.pathname === '/api/ctm/session-memory/rebuild-message-index')
+      && req.method === 'POST'
+    ) {
+      readJsonBody(req, 32 * 1024)
+        .then((body) => handleMessageIndexBackfill({ body, res, context, db, dbModule })
+          .catch((err) => respondJson(res, 500, {
+            ok: false,
+            source: 'ctm-api',
+            authority: 'ctm',
+            reason: 'ctm_message_index_backfill_failed',
+            error: err.message,
+          })))
+        .catch((err) => respondJson(res, 400, {
+          ok: false,
+          source: 'ctm-api',
+          reason: 'invalid_json',
+          error: err.message,
+        }));
+      return true;
+    }
+
+    if (url.pathname === '/api/ctm/session-memory/context-pack' && req.method === 'POST') {
+      readJsonBody(req, 128 * 1024)
+        .then((body) => {
+          respondJson(res, 200, asApiResult(context.buildContextPack({
+            task: body.task || '',
+            query: body.query || '',
+            session_ids: body.session_ids || body.ids,
+            limit: body.limit,
+            token_budget: body.token_budget,
+            include_raw: Boolean(body.include_raw),
+            mode: body.mode || 'auto',
+            db,
+          })));
+        })
+        .catch((err) => respondJson(res, 400, {
+          ok: false,
+          source: 'ctm-api',
+          reason: 'invalid_json',
+          error: err.message,
+        }));
+      return true;
+    }
+
+    return respondJson(res, 404, {
+      ok: false,
+      source: 'ctm-api',
+      reason: 'not_found',
+    });
+  } catch (err) {
+    return respondJson(res, 500, {
+      ok: false,
+      source: 'ctm-api',
+      reason: 'ctm_session_context_failed',
+      error: err.message,
+    });
+  }
+}
+
+async function handleMessageIndexBackfill({ body, res, context, db, dbModule }) {
+  const limit = clampInt(body.limit, 100, 1, 1000);
+  const chunkSize = clampInt(body.chunk_size ?? body.chunkSize, 250, 25, 2000);
+  const dryRun = parseBool(body.dry_run);
+  if (dryRun) {
+    return respondJson(res, 200, asApiResult(context.backfillCtmSessionMessages({
+      db,
+      limit,
+      dry_run: true,
+    })));
+  }
+
+  if (!dbModule || typeof dbModule.backfillSessionMessagesAsync !== 'function') {
+    return respondJson(res, 503, {
+      ok: false,
+      source: 'ctm-api',
+      authority: 'ctm',
+      reason: 'ctm_message_index_writer_unavailable',
+    });
+  }
+
+  const insertedMessages = await dbModule.backfillSessionMessagesAsync({ limit, chunkSize });
+  return respondJson(res, 200, asApiResult({
+    ok: true,
+    source: 'ctm-db',
+    dry_run: false,
+    limit,
+    chunk_size: chunkSize,
+    inserted_messages: insertedMessages,
+    table_counts: tableCounts(db, ['session_conversations', 'session_messages', 'session_messages_fts']),
+  }));
+}
+
+function asApiResult(result) {
+  return {
+    ...(result || {}),
+    source: 'ctm-api',
+    backend_source: result?.source || 'ctm-db',
+    authority: 'ctm',
+  };
+}
+
+function parseListParams(searchParams, ...names) {
+  const values = [];
+  for (const name of names) {
+    for (const value of searchParams.getAll(name)) {
+      values.push(...String(value || '').split(','));
+    }
+  }
+  return values.map((value) => value.trim()).filter(Boolean);
+}
+
+function parseBool(value) {
+  return value === true || value === 1 || value === '1' || value === 'true' || value === 'yes';
+}
+
+function clampInt(value, fallback, min, max) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return fallback;
+  return Math.min(Math.max(Math.trunc(n), min), max);
+}
+
+function tableCounts(db, names) {
+  const counts = {};
+  if (!db) return counts;
+  for (const name of names) {
+    try {
+      const exists = db.prepare("SELECT 1 FROM sqlite_master WHERE type IN ('table', 'view') AND name = ?").get(name);
+      if (!exists) continue;
+      counts[name] = db.prepare(`SELECT COUNT(*) AS count FROM ${name}`).get().count;
+    } catch (err) {
+      counts._errors = counts._errors || {};
+      counts._errors[name] = err.message;
+    }
+  }
+  return counts;
+}
+
+function readJsonBody(req, maxBytes) {
+  return new Promise((resolve, reject) => {
+    let body = '';
+    req.on('data', (chunk) => {
+      body += chunk;
+      if (body.length > maxBytes) {
+        reject(new Error('request_body_too_large'));
+        req.destroy();
+      }
+    });
+    req.on('end', () => {
+      try {
+        resolve(body ? JSON.parse(body) : {});
+      } catch (err) {
+        reject(err);
+      }
+    });
+    req.on('error', reject);
+  });
+}
+
+function respondJson(res, status, payload) {
+  res.writeHead(status, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify(payload));
+  return true;
+}
+
+module.exports = {
+  handleCtmSessionContextApi,
+  loadCtmSessionContext,
+};

package/template/claude-task-manager/lib/session-diagnostics.js

@@ -0,0 +1,56 @@
+'use strict';
+
+function createSessionDiagnostics({ limit = 80, clock = () => Date.now() } = {}) {
+  const rings = new Map();
+  const cap = Math.max(1, Math.min(Number(limit) || 80, 500));
+
+  function record(sessionId, event, details = {}) {
+    const id = String(sessionId || '').trim();
+    if (!id) return null;
+    const entry = {
+      ts: clock(),
+      event: String(event || 'event'),
+      ...sanitizeDetails(details),
+    };
+    const ring = rings.get(id) || [];
+    ring.push(entry);
+    while (ring.length > cap) ring.shift();
+    rings.set(id, ring);
+    return entry;
+  }
+
+  function get(sessionId) {
+    const id = String(sessionId || '').trim();
+    return [...(rings.get(id) || [])];
+  }
+
+  function clear(sessionId) {
+    rings.delete(String(sessionId || '').trim());
+  }
+
+  return { record, get, clear };
+}
+
+function sanitizeDetails(details) {
+  const out = {};
+  for (const [key, value] of Object.entries(details || {})) {
+    if (value == null) continue;
+    if (typeof value === 'string') {
+      out[key] = value.length > 500 ? `${value.slice(0, 497)}...` : value;
+    } else if (typeof value === 'number' || typeof value === 'boolean') {
+      out[key] = value;
+    } else if (Array.isArray(value)) {
+      out[key] = value.slice(0, 20).map((item) => (
+        typeof item === 'string' && item.length > 200 ? `${item.slice(0, 197)}...` : item
+      ));
+    } else if (typeof value === 'object') {
+      out[key] = sanitizeDetails(value);
+    }
+  }
+  return out;
+}
+
+module.exports = {
+  createSessionDiagnostics,
+  sanitizeDetails,
+};