@causyne/agent 1.10.13 → 1.10.17

package/src/sessionStore.js

@@ -1,279 +1,3 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import crypto from 'crypto';
-import { causyneHome } from './utils/paths.js';
-
-// Chat sessions. One conversation, one file, scoped to one workspace.
-//
-// WHAT THIS REPLACES, AND WHY IT HAD TO GO.
-//
-// There was exactly one `~/.causyne/memory/chat_history.json`. No id, no
-// workspace key, no time bound. Every invocation of Causyne, in every directory,
-// on every project, loaded the SAME conversation. So:
-//
-//   work on Causyne in ~/Causyne        -> history saved
-//   weeks later, open ~/Desktop/3d    -> the SAME history loads
-//   type "continue"                   -> the agent resumes the Causyne
-//                                        conversation, in the Blender directory,
-//                                        and goes scanning the old project
-//
-// That is not a memory feature working. It is one unbounded conversation
-// impersonating a memory, and it gets worse every day it is used: context from
-// months-old work leaks into today's task, and work from one client's project
-// leaks into another's.
-//
-// THE MODEL, taken from opencode's SessionV2.Info (id, projectID, title,
-// time.created/updated/archived): a session belongs to a WORKSPACE and is
-// resumed only when it is both the same workspace and recent. A different
-// directory is a different conversation. An old conversation in the same
-// directory is still there — listed, switchable — but it does not silently
-// become the thing "continue" continues.
-
-const SESSION_DIR = path.join(causyneHome(), 'sessions');
-const LEGACY_HISTORY = path.join(causyneHome(), 'memory', 'chat_history.json');
-const POINTER_FILE = path.join(SESSION_DIR, 'active.json');
-
-/**
- * How long a session stays resumable in its own workspace.
- *
- * Past this, returning to the directory starts a NEW conversation rather than
- * reviving one whose subject you have forgotten. The old one is still listed
- * and can be resumed by name — the point is that it stops being the default.
- */
-const RESUME_WINDOW_MS = 12 * 60 * 60 * 1000;
-
-/** Hard ceiling on retained sessions. The oldest are archived out first. */
-const MAX_SESSIONS = 50;
-
-function ensureDir() {
-  if (!fs.existsSync(SESSION_DIR)) fs.mkdirSync(SESSION_DIR, { recursive: true, mode: 0o700 });
-}
-
-/** A stable, filesystem-safe key for a workspace path. */
-function workspaceKey(workspace) {
-  return crypto.createHash('sha256').update(String(workspace || '')).digest('hex').slice(0, 12);
-}
-
-function sessionFile(id) {
-  const safe = String(id || '').replace(/[^a-zA-Z0-9_-]/g, '');
-  return path.join(SESSION_DIR, `${safe}.json`);
-}
-
-/**
- * A short human title from the first thing the user actually asked for.
- *
- * `chat_history.json` had no title at all, which is why nothing could ever be
- * listed or chosen. A session you cannot name is a session you cannot leave.
- */
-export function titleFrom(text) {
-  const clean = String(text || '').replace(/\s+/g, ' ').trim();
-  if (!clean) return 'Untitled';
-  return clean.length > 60 ? clean.slice(0, 57) + '…' : clean;
-}
-
-function readSession(id) {
-  try {
-    const file = sessionFile(id);
-    if (!fs.existsSync(file)) return null;
-    return JSON.parse(fs.readFileSync(file, 'utf8'));
-  } catch (e) {
-    return null; // a corrupt session degrades to "no session", never to a crash
-  }
-}
-
-function writeSession(session) {
-  try {
-    ensureDir();
-    fs.writeFileSync(sessionFile(session.id), JSON.stringify(session, null, 2), { mode: 0o600 });
-    return true;
-  } catch (e) {
-    return false; // fail open: losing a session must not fail the task
-  }
-}
-
-/** Every session, newest first. Messages are NOT loaded — this is the index. */
-export function listSessions() {
-  try {
-    ensureDir();
-    const rows = [];
-    for (const name of fs.readdirSync(SESSION_DIR)) {
-      if (!name.endsWith('.json') || name === 'active.json') continue;
-      const session = readSession(name.replace(/\.json$/, ''));
-      if (!session) continue;
-      rows.push({
-        id: session.id,
-        title: session.title || 'Untitled',
-        workspace: session.workspace || '',
-        createdAt: session.createdAt || 0,
-        updatedAt: session.updatedAt || 0,
-        messageCount: Array.isArray(session.messages) ? session.messages.length : 0
-      });
-    }
-    return rows.sort((a, b) => b.updatedAt - a.updatedAt);
-  } catch (e) {
-    return [];
-  }
-}
-
-/**
- * Retire the oldest sessions past MAX_SESSIONS.
- *
- * Called at session resolution rather than on a timer — nothing may run in the
- * background (ZM-01), and a session boundary is often enough for a ceiling
- * measured in dozens.
- */
-export function pruneSessions(max = MAX_SESSIONS) {
-  try {
-    const all = listSessions();
-    let removed = 0;
-    for (const row of all.slice(max)) {
-      try { fs.unlinkSync(sessionFile(row.id)); removed++; } catch (e) { /* skip */ }
-    }
-    return removed;
-  } catch (e) {
-    return 0;
-  }
-}
-
-export function createSession(workspace, title = 'Untitled') {
-  const now = Date.now();
-  const session = {
-    id: `s_${now.toString(36)}_${crypto.randomBytes(3).toString('hex')}`,
-    workspace: String(workspace || ''),
-    workspaceKey: workspaceKey(workspace),
-    title,
-    createdAt: now,
-    updatedAt: now,
-    messages: []
-  };
-  writeSession(session);
-  setActiveSession(session.id);
-  pruneSessions();
-  return session;
-}
-
-export function getActiveSessionId() {
-  try {
-    if (!fs.existsSync(POINTER_FILE)) return null;
-    return JSON.parse(fs.readFileSync(POINTER_FILE, 'utf8')).id || null;
-  } catch (e) {
-    return null;
-  }
-}
-
-export function setActiveSession(id) {
-  try {
-    ensureDir();
-    fs.writeFileSync(POINTER_FILE, JSON.stringify({ id, at: Date.now() }, null, 2), { mode: 0o600 });
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-
-/**
- * The session this workspace should be using right now.
- *
- * THE RULE THAT FIXES THE BOOMERANG: resume only when the workspace matches AND
- * the conversation is recent. Anything else starts fresh. A different directory
- * is a different conversation, full stop.
- *
- * @param   {string} workspace  Usually process.cwd().
- * @returns {object}            The session, with its messages loaded.
- */
-export function resolveSession(workspace) {
-  ensureDir();
-  migrateLegacyHistory(workspace);
-
-  const key = workspaceKey(workspace);
-  const now = Date.now();
-
-  const candidate = listSessions()
-    .filter(row => row.workspace && workspaceKey(row.workspace) === key)
-    .find(row => now - row.updatedAt < RESUME_WINDOW_MS);
-
-  if (candidate) {
-    const session = readSession(candidate.id);
-    if (session) {
-      setActiveSession(session.id);
-      return session;
-    }
-  }
-
-  return createSession(workspace);
-}
-
-/** Load a specific session by id, making it active. */
-export function switchSession(id) {
-  const session = readSession(id);
-  if (!session) return null;
-  setActiveSession(session.id);
-  return session;
-}
-
-/** Persist a session's messages. Title is set once, from the first user turn. */
-export function saveSessionMessages(id, messages) {
-  const session = readSession(id);
-  if (!session) return false;
-
-  session.messages = Array.isArray(messages) ? messages : [];
-  session.updatedAt = Date.now();
-
-  if (!session.title || session.title === 'Untitled') {
-    const firstUser = session.messages.find(m => m.role === 'user' && typeof m.content === 'string');
-    if (firstUser) session.title = titleFrom(firstUser.content);
-  }
-
-  return writeSession(session);
-}
-
-export function deleteSession(id) {
-  try {
-    fs.unlinkSync(sessionFile(id));
-    if (getActiveSessionId() === id) setActiveSession(null);
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-
-/**
- * Move the one global history into a session, once.
- *
- * Nothing is thrown away — the conversation that existed becomes a session
- * belonging to the workspace it is first seen from, and the legacy file is
- * renamed rather than deleted so it can be recovered if the migration is wrong.
- */
-export function migrateLegacyHistory(workspace) {
-  try {
-    if (!fs.existsSync(LEGACY_HISTORY)) return null;
-
-    const raw = fs.readFileSync(LEGACY_HISTORY, 'utf8');
-    const messages = JSON.parse(raw);
-    if (!Array.isArray(messages) || messages.length === 0) {
-      fs.renameSync(LEGACY_HISTORY, LEGACY_HISTORY + '.migrated');
-      return null;
-    }
-
-    const firstUser = messages.find(m => m.role === 'user' && typeof m.content === 'string');
-    const session = createSession(workspace, titleFrom(firstUser ? firstUser.content : 'Imported conversation'));
-    session.messages = messages.filter(m => m.role !== 'system');
-    session.createdAt = fs.statSync(LEGACY_HISTORY).mtimeMs;
-    // NO WORKSPACE, deliberately. The legacy file belonged to every directory
-    // at once, so attaching it to whichever one happens to migrate it first
-    // would just recreate the boomerang somewhere arbitrary. It stays listed
-    // and switchable by name; it is never what `continue` continues.
-    session.workspace = '';
-    session.workspaceKey = '';
-    session.title = session.title === 'Untitled' ? 'Imported conversation' : session.title + ' (imported)';
-    writeSession(session);
-
-    fs.renameSync(LEGACY_HISTORY, LEGACY_HISTORY + '.migrated');
-    return session;
-  } catch (e) {
-    return null;
-  }
-}
-
-export { SESSION_DIR, RESUME_WINDOW_MS, MAX_SESSIONS };
+// Compatibility surface during the incremental TypeScript migration.
+// `npm run build` compiles sessionJournal.ts to readable ESM beside this file.
+export * from './sessionJournal.js';

package/src/skillsManager.js

@@ -3,6 +3,7 @@ import path from 'path';
 
 import { COMPILED_SKILLS } from './compiledSkills.js';
 import { loadUserSkills } from './userSkills.js';
+import { getPluginSkills } from './plugins/pluginManager.js';
 
 // User skills are read from disk, and the disk is slow relative to how often
 // these functions are called (every completion keystroke asks for the
@@ -259,6 +260,19 @@ export function listCompiledSkills() {
     });
   }
 
+  // Plugin skills live in a plugin-owned namespace (`plugin-<name>/...`) and
+  // appear only after explicit digest-pinned enablement. A user's own skill can
+  // still shadow one, which preserves local authority over every instruction.
+  for (const skill of getPluginSkills()) {
+    const key = `${skill.domain}/${skill.id}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    out.push({
+      domain: skill.domain, id: skill.id, name: skill.name,
+      description: skill.description, source: 'plugin'
+    });
+  }
+
   for (const [domain, skills] of Object.entries(COMPILED_SKILLS)) {
     for (const [id, data] of Object.entries(skills)) {
       if (seen.has(`${domain}/${id}`)) continue;
@@ -278,6 +292,10 @@ export function readCompiledSkill(domain, skillId) {
     .find((skill) => skill.domain === domain && skill.id === skillId);
   if (own) return own.content;
 
+  const pluginSkill = getPluginSkills()
+    .find((skill) => skill.domain === domain && skill.id === skillId);
+  if (pluginSkill) return pluginSkill.content;
+
   const domainSkills = COMPILED_SKILLS[domain];
   if (!domainSkills) return `Error: Domain ${domain} not found in compiled skills.`;
 

package/src/subagentJournal.js

@@ -0,0 +1,215 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { causyneHome } from './utils/paths.js';
+const ROOT = path.join(causyneHome(), 'subagents');
+const SAFE_ID = /^sub_[a-zA-Z0-9_-]{1,120}$/;
+const MAX_MESSAGES = 500;
+const MAX_CONTENT_BYTES = 128 * 1024;
+const MAX_EVENT_BYTES = 512 * 1024;
+const MAX_JOURNAL_BYTES = 16 * 1024 * 1024;
+function ensureRoot() {
+    if (!fs.existsSync(ROOT))
+        fs.mkdirSync(ROOT, { recursive: true, mode: 0o700 });
+}
+function safeId(value) {
+    const id = String(value ?? '');
+    return SAFE_ID.test(id) ? id : null;
+}
+export function subagentJournalFile(id) {
+    const safe = safeId(id);
+    return safe ? path.join(ROOT, `${safe}.jsonl`) : null;
+}
+function boundedText(value, maximumBytes) {
+    const text = String(value ?? '');
+    if (Buffer.byteLength(text, 'utf8') <= maximumBytes)
+        return text;
+    let end = Math.min(text.length, maximumBytes);
+    while (end > 0 && Buffer.byteLength(text.slice(0, end), 'utf8') > maximumBytes)
+        end -= 1;
+    return `${text.slice(0, end)}\n[truncated by Causyne]`;
+}
+function boundedMessage(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const input = value;
+    if (typeof input.role !== 'string')
+        return null;
+    let content = input.content;
+    if (typeof content === 'string') {
+        content = boundedText(content, MAX_CONTENT_BYTES);
+    }
+    else {
+        try {
+            const serialized = JSON.stringify(content);
+            content = Buffer.byteLength(serialized, 'utf8') <= MAX_CONTENT_BYTES
+                ? JSON.parse(serialized)
+                : '[structured content omitted: exceeds sidechain limit]';
+        }
+        catch {
+            content = '[unserializable content omitted]';
+        }
+    }
+    const message = { role: input.role, content };
+    for (const key of ['name', 'tool_call_id']) {
+        if (typeof input[key] === 'string')
+            message[key] = input[key];
+    }
+    return message;
+}
+function appendEvent(file, event) {
+    try {
+        const line = `${JSON.stringify(event)}\n`;
+        if (Buffer.byteLength(line, 'utf8') > MAX_EVENT_BYTES)
+            return false;
+        fs.appendFileSync(file, line, { encoding: 'utf8', mode: 0o600, flag: 'a' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function startSubagentJournal(input) {
+    const file = subagentJournalFile(input.subagentId);
+    if (!file)
+        return false;
+    try {
+        ensureRoot();
+        const event = {
+            version: 1,
+            type: 'subagent.started',
+            at: Date.now(),
+            subagentId: input.subagentId,
+            name: boundedText(input.name, 256),
+            prompt: boundedText(input.prompt, 32 * 1024),
+            profile: input.profile ?? null,
+            toolScope: input.toolScope.slice(0, 64),
+            maxSteps: input.maxSteps,
+            maxTokens: input.maxTokens
+        };
+        fs.writeFileSync(file, `${JSON.stringify(event)}\n`, { encoding: 'utf8', mode: 0o600, flag: 'wx' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function completeSubagentJournal(id, messages, result) {
+    const file = subagentJournalFile(id);
+    if (!file || !fs.existsSync(file))
+        return false;
+    let ok = true;
+    for (const value of messages.slice(-MAX_MESSAGES)) {
+        const message = boundedMessage(value);
+        if (!message)
+            continue;
+        ok = appendEvent(file, { version: 1, type: 'message.recorded', at: Date.now(), message }) && ok;
+    }
+    return appendEvent(file, {
+        version: 1,
+        type: 'subagent.completed',
+        at: Date.now(),
+        result
+    }) && ok;
+}
+export function failSubagentJournal(id, error) {
+    const file = subagentJournalFile(id);
+    if (!file || !fs.existsSync(file))
+        return false;
+    return appendEvent(file, {
+        version: 1,
+        type: 'subagent.failed',
+        at: Date.now(),
+        error: boundedText(error, 8 * 1024)
+    });
+}
+export function readSubagentJournal(id) {
+    const file = subagentJournalFile(id);
+    if (!file)
+        return null;
+    const requestedId = safeId(id);
+    if (!requestedId)
+        return null;
+    try {
+        const stat = fs.statSync(file);
+        if (!stat.isFile() || stat.size > MAX_JOURNAL_BYTES)
+            return null;
+        const text = fs.readFileSync(file, 'utf8');
+        const trailingNewline = text.endsWith('\n');
+        const lines = text.split('\n');
+        if (lines.at(-1) === '')
+            lines.pop();
+        let projection = null;
+        for (let index = 0; index < lines.length; index += 1) {
+            const line = lines[index];
+            if (!line)
+                continue;
+            let event;
+            try {
+                event = JSON.parse(line);
+            }
+            catch {
+                if (index === lines.length - 1 && !trailingNewline)
+                    break;
+                return null;
+            }
+            if (event === null || typeof event !== 'object' || Array.isArray(event))
+                return null;
+            const record = event;
+            if (record.version !== 1 || typeof record.type !== 'string' || typeof record.at !== 'number')
+                return null;
+            if (record.type === 'subagent.started') {
+                if (projection
+                    || typeof record.subagentId !== 'string'
+                    || record.subagentId !== requestedId
+                    || typeof record.name !== 'string'
+                    || typeof record.prompt !== 'string'
+                    || !Array.isArray(record.toolScope)
+                    || typeof record.maxSteps !== 'number'
+                    || typeof record.maxTokens !== 'number')
+                    return null;
+                projection = {
+                    subagentId: record.subagentId,
+                    name: record.name,
+                    prompt: record.prompt,
+                    profile: typeof record.profile === 'string' ? record.profile : null,
+                    toolScope: record.toolScope.filter((tool) => typeof tool === 'string'),
+                    maxSteps: record.maxSteps,
+                    maxTokens: record.maxTokens,
+                    startedAt: record.at,
+                    updatedAt: record.at,
+                    status: 'running',
+                    messages: [],
+                    result: null,
+                    error: null
+                };
+                continue;
+            }
+            if (!projection)
+                return null;
+            projection.updatedAt = record.at;
+            if (record.type === 'message.recorded') {
+                if (record.message === null || typeof record.message !== 'object' || Array.isArray(record.message))
+                    return null;
+                projection.messages.push(record.message);
+            }
+            else if (record.type === 'subagent.completed') {
+                projection.status = 'completed';
+                projection.result = record.result !== null && typeof record.result === 'object' && !Array.isArray(record.result)
+                    ? record.result
+                    : {};
+            }
+            else if (record.type === 'subagent.failed') {
+                projection.status = 'failed';
+                projection.error = typeof record.error === 'string' ? record.error : 'unknown failure';
+            }
+            else {
+                return null;
+            }
+        }
+        return projection;
+    }
+    catch {
+        return null;
+    }
+}
+export { ROOT as SUBAGENT_JOURNAL_ROOT };