@geminilight/mindos 0.5.64 → 0.5.66

package/app/lib/agent/log.ts

@@ -1,9 +1,9 @@
 import fs from 'fs';
 import path from 'path';
 import { getMindRoot } from '@/lib/fs';
+import { appendAgentAuditEvent } from '@/lib/core/agent-audit-log';
 
-const LOG_FILE = '.agent-log.json';
-const MAX_SIZE = 500 * 1024; // 500KB
+const LEGACY_LOG_FILE = '.agent-log.json';
 
 interface AgentOpEntry {
   ts: string;
@@ -22,23 +22,20 @@ interface AgentOpEntry {
 export function logAgentOp(entry: AgentOpEntry): void {
   try {
     const root = getMindRoot();
-    const logPath = path.join(root, LOG_FILE);
-
-    const line = JSON.stringify(entry) + '\n';
-
-    // Check size and truncate if needed
-    if (fs.existsSync(logPath)) {
-      const stat = fs.statSync(logPath);
-      if (stat.size > MAX_SIZE) {
-        const content = fs.readFileSync(logPath, 'utf-8');
-        const lines = content.trimEnd().split('\n');
-        // Keep the newer half
-        const kept = lines.slice(Math.floor(lines.length / 2));
-        fs.writeFileSync(logPath, kept.join('\n') + '\n');
-      }
+    appendAgentAuditEvent(root, {
+      ts: entry.ts,
+      tool: entry.tool,
+      params: entry.params,
+      result: entry.result,
+      message: entry.message,
+      durationMs: entry.durationMs,
+    });
+    // Best-effort cleanup of legacy JSONL path.
+    try {
+      fs.rmSync(path.join(root, LEGACY_LOG_FILE), { force: true });
+    } catch {
+      // ignore
     }
-
-    fs.appendFileSync(logPath, line);
   } catch {
     // Logging should never break tool execution
   }

package/app/lib/agent/prompt.ts

@@ -9,39 +9,27 @@
  * Token budget: ~600 tokens (down from ~900 in v2). Freed space = more room for
  * SKILL.md + bootstrap context within the same context window.
  */
-export const AGENT_SYSTEM_PROMPT = `You are MindOS Agent — a personal knowledge-base operator that reads, writes, and organizes a user's second brain.
+export const AGENT_SYSTEM_PROMPT = `You are MindOS Agent — the operator of the user's second brain.
 
-Persona: methodical, concise, execution-oriented. You surface what you found (or didn't find) and act on it — no filler, no caveats that add no information.
+Persona: Methodical, strictly objective, execution-oriented. Zero fluff. Never use preambles like "Here is the result" or "I found...".
 
-## What is already loaded
+## Core Directives
 
-The server auto-loads before each request:
-- Bootstrap context: INSTRUCTION.md, README.md, CONFIG files, and directory-local guidance.
-- Skill guidance (SKILL.md): detailed knowledge-base rules, tool selection, execution patterns.
-- Tool definitions with per-tool usage instructions.
+1. **Anti-Hallucination**: Strictly separate your training data from the user's local knowledge. If asked about the user's notes/life/projects, rely EXCLUSIVELY on tool outputs. If a search yields nothing, state "Not found in knowledge base." NEVER fabricate or infer missing data.
+2. **Think Before Acting**: For any non-trivial task, use a brief \`<thinking>\` block to outline your plan or analyze an error BEFORE calling tools.
+3. **Read Before Write**: You MUST read a file before modifying it. Prefer precise section/line edits over full overwrites. Verify edits by reading again.
+4. **Cite Sources**: Always include the exact file path when answering from local knowledge so the user can verify.
+5. **Smart Recovery**: If a tool fails (e.g., File Not Found), do NOT retry identical arguments. Use \`search\` or \`list_files\` to find the correct path first.
+6. **Token Efficiency**: Batch parallel independent tool calls in a single turn. Do not waste rounds.
+7. **Language Alignment**: Match the language of the file when writing, and match the user's language when replying.
 
-Treat these as your initialization baseline. If the task needs fresher or broader evidence, call tools proactively before concluding.
+## Context Mechanics
 
-## Behavioral rules
+- **Auto-loaded**: Configs, instructions, and SKILL.md are already in your context. Do not search for them unless explicitly asked.
+- **Uploaded Files**: Local files attached by the user appear in the "⚠️ USER-UPLOADED FILES" section below. Use this content directly. Do NOT use tools to read/search them.
 
-1. **Read before write.** Never modify a file you haven't read in this request.
-2. **Minimal edits.** Prefer section/heading/line-level tools over full file overwrites.
-3. **Verify after edit.** Re-read the changed file to confirm correctness.
-4. **Cite sources.** When answering from stored knowledge, state the file path so the user can verify.
-5. **Fail fast.** If a tool call returns an error or unexpected result, try a different approach or ask the user — do not retry identical arguments.
-6. **Be token-aware.** You have a limited step budget (typically 10-30). Batch parallel reads/searches when possible. Do not waste steps on redundant tool calls.
-7. **Multilingual content, user-language replies.** Write file content in whatever language the file already uses. Reply to the user in the language they used.
+## Output
 
-## Uploaded files
-
-Users may upload local files (PDF, txt, csv, etc.) via the chat interface.
-- Their content appears in a "⚠️ USER-UPLOADED FILES" section near the end of this prompt.
-- Use that content directly — do NOT call read_file or search tools for uploaded files; they are not in the knowledge base.
-- If the section is empty or missing, tell the user the upload may have failed.
-
-## Output format
-
-- Answer in the user's language.
-- Use Markdown when it improves clarity (headings, lists, tables, code blocks).
-- For multi-step tasks: output a brief numbered plan, execute, then summarize outcomes.
-- End with concrete next actions when applicable.`;
+- Reply in the user's language.
+- Use clean Markdown (tables, lists, bold).
+- End with concrete next actions if the task is incomplete.`;

package/app/lib/agent/stream-consumer.ts

@@ -31,6 +31,8 @@ export async function consumeUIMessageStream(
   let currentTextId: string | null = null;
   let currentReasoningPart: ReasoningPart | null = null;
 
+  const startedAt = Date.now();
+
   /** Build an immutable Message snapshot from current parts */
   function buildMessage(): Message {
     const clonedParts: MessagePart[] = parts.map(p => {
@@ -47,6 +49,7 @@ export async function consumeUIMessageStream(
       role: 'assistant',
       content: textContent,
       parts: clonedParts,
+      timestamp: startedAt,
     };
   }
 

package/app/lib/agent/to-agent-messages.ts

@@ -24,11 +24,13 @@ export function toAgentMessages(messages: FrontendMessage[]): AgentMessage[] {
   const result: AgentMessage[] = [];
 
   for (const msg of messages) {
+    const timestamp = msg.timestamp ?? Date.now();
+
     if (msg.role === 'user') {
       result.push({
         role: 'user',
         content: msg.content,
-        timestamp: Date.now(),
+        timestamp,
       } satisfies UserMessage as AgentMessage);
       continue;
     }
@@ -49,7 +51,7 @@ export function toAgentMessages(messages: FrontendMessage[]): AgentMessage[] {
           model: '',
           usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
           stopReason: 'stop',
-          timestamp: Date.now(),
+          timestamp,
         } satisfies AssistantMessage as AgentMessage);
       }
       continue;
@@ -85,7 +87,7 @@ export function toAgentMessages(messages: FrontendMessage[]): AgentMessage[] {
         model: '',
         usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0, cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } },
         stopReason: toolCalls.length > 0 ? 'toolUse' : 'stop',
-        timestamp: Date.now(),
+        timestamp,
       } satisfies AssistantMessage as AgentMessage);
     }
 
@@ -97,7 +99,7 @@ export function toAgentMessages(messages: FrontendMessage[]): AgentMessage[] {
         toolName: tc.toolName,
         content: [{ type: 'text', text: tc.output ?? '' }],
         isError: tc.state === 'error',
-        timestamp: Date.now(),
+        timestamp,
       } satisfies ToolResultMessage as AgentMessage);
     }
   }

package/app/lib/core/agent-audit-log.ts

@@ -0,0 +1,280 @@
+import fs from 'fs';
+import path from 'path';
+
+export interface AgentAuditEvent {
+  id: string;
+  ts: string;
+  tool: string;
+  params: Record<string, unknown>;
+  result: 'ok' | 'error';
+  message?: string;
+  durationMs?: number;
+  op?: 'append' | 'legacy_agent_audit_md_import' | 'legacy_agent_log_jsonl_import';
+}
+
+export interface AgentAuditInput {
+  ts: string;
+  tool: string;
+  params: Record<string, unknown>;
+  result: 'ok' | 'error';
+  message?: string;
+  durationMs?: number;
+}
+
+interface AgentAuditState {
+  version: 1;
+  events: AgentAuditEvent[];
+  legacy?: {
+    mdImportedCount?: number;
+    jsonlImportedCount?: number;
+    lastImportedAt?: string | null;
+  };
+}
+
+const LOG_DIR_NAME = '.mindos';
+const LOG_FILE_NAME = 'agent-audit-log.json';
+const LEGACY_MD_FILE = 'Agent-Audit.md';
+const LEGACY_JSONL_FILE = '.agent-log.json';
+const MAX_EVENTS = 1000;
+const MAX_MESSAGE_CHARS = 2000;
+
+function nowIso() {
+  return new Date().toISOString();
+}
+
+function validIso(ts: string | undefined): string {
+  if (!ts) return nowIso();
+  const ms = new Date(ts).getTime();
+  return Number.isFinite(ms) ? new Date(ms).toISOString() : nowIso();
+}
+
+function normalizeMessage(message: string | undefined): string | undefined {
+  if (typeof message !== 'string') return undefined;
+  if (message.length <= MAX_MESSAGE_CHARS) return message;
+  return message.slice(0, MAX_MESSAGE_CHARS);
+}
+
+function defaultState(): AgentAuditState {
+  return {
+    version: 1,
+    events: [],
+    legacy: {
+      mdImportedCount: 0,
+      jsonlImportedCount: 0,
+      lastImportedAt: null,
+    },
+  };
+}
+
+function logPath(mindRoot: string) {
+  return path.join(mindRoot, LOG_DIR_NAME, LOG_FILE_NAME);
+}
+
+function readState(mindRoot: string): AgentAuditState {
+  const file = logPath(mindRoot);
+  try {
+    if (!fs.existsSync(file)) return defaultState();
+    const parsed = JSON.parse(fs.readFileSync(file, 'utf-8')) as Partial<AgentAuditState>;
+    if (!Array.isArray(parsed.events)) return defaultState();
+    return {
+      version: 1,
+      events: parsed.events,
+      legacy: {
+        mdImportedCount: typeof parsed.legacy?.mdImportedCount === 'number' ? parsed.legacy.mdImportedCount : 0,
+        jsonlImportedCount: typeof parsed.legacy?.jsonlImportedCount === 'number' ? parsed.legacy.jsonlImportedCount : 0,
+        lastImportedAt: typeof parsed.legacy?.lastImportedAt === 'string' ? parsed.legacy.lastImportedAt : null,
+      },
+    };
+  } catch {
+    return defaultState();
+  }
+}
+
+function writeState(mindRoot: string, state: AgentAuditState): void {
+  const file = logPath(mindRoot);
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  fs.writeFileSync(file, JSON.stringify(state, null, 2), 'utf-8');
+}
+
+function removeLegacyFile(filePath: string): void {
+  try {
+    fs.rmSync(filePath, { force: true });
+  } catch {
+    // Keep migration best-effort.
+  }
+}
+
+interface LegacyAgentOp {
+  ts?: string;
+  tool?: string;
+  params?: Record<string, unknown>;
+  result?: 'ok' | 'error';
+  message?: string;
+  durationMs?: number;
+}
+
+function parseLegacyMdBlocks(raw: string): LegacyAgentOp[] {
+  const blocks: LegacyAgentOp[] = [];
+  const re = /```agent-op\s*\n([\s\S]*?)```/g;
+  let match: RegExpExecArray | null;
+  while ((match = re.exec(raw)) !== null) {
+    try {
+      blocks.push(JSON.parse(match[1].trim()) as LegacyAgentOp);
+    } catch {
+      // Ignore malformed blocks.
+    }
+  }
+  return blocks;
+}
+
+function parseJsonLines(raw: string): LegacyAgentOp[] {
+  const entries: LegacyAgentOp[] = [];
+  for (const line of raw.split('\n')) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('//')) continue;
+    try {
+      entries.push(JSON.parse(trimmed) as LegacyAgentOp);
+    } catch {
+      // Ignore malformed lines.
+    }
+  }
+  return entries;
+}
+
+function toEvent(entry: LegacyAgentOp, op: AgentAuditEvent['op'], idx: number): AgentAuditEvent {
+  const tool = typeof entry.tool === 'string' && entry.tool.trim() ? entry.tool.trim() : 'unknown-tool';
+  const result = entry.result === 'error' ? 'error' : 'ok';
+  const params = entry.params && typeof entry.params === 'object' ? entry.params : {};
+  return {
+    id: `legacy-${Date.now().toString(36)}-${idx.toString(36)}`,
+    ts: validIso(entry.ts),
+    tool,
+    params,
+    result,
+    message: normalizeMessage(entry.message),
+    durationMs: typeof entry.durationMs === 'number' ? entry.durationMs : undefined,
+    op,
+  };
+}
+
+function importLegacyMdIfNeeded(mindRoot: string, state: AgentAuditState): AgentAuditState {
+  const legacyPath = path.join(mindRoot, LEGACY_MD_FILE);
+  if (!fs.existsSync(legacyPath)) return state;
+
+  let raw = '';
+  try {
+    raw = fs.readFileSync(legacyPath, 'utf-8');
+  } catch {
+    return state;
+  }
+
+  const blocks = parseLegacyMdBlocks(raw);
+  const importedCount = state.legacy?.mdImportedCount ?? 0;
+  if (blocks.length <= importedCount) {
+    if (blocks.length > 0) removeLegacyFile(legacyPath);
+    return state;
+  }
+
+  const incoming = blocks.slice(importedCount);
+  const imported = incoming.map((entry, idx) => toEvent(entry, 'legacy_agent_audit_md_import', idx));
+  const merged = [...state.events, ...imported]
+    .sort((a, b) => new Date(b.ts).getTime() - new Date(a.ts).getTime())
+    .slice(0, MAX_EVENTS);
+
+  const next = {
+    ...state,
+    events: merged,
+    legacy: {
+      mdImportedCount: blocks.length,
+      jsonlImportedCount: state.legacy?.jsonlImportedCount ?? 0,
+      lastImportedAt: nowIso(),
+    },
+  };
+  removeLegacyFile(legacyPath);
+  return next;
+}
+
+function importLegacyJsonlIfNeeded(mindRoot: string, state: AgentAuditState): AgentAuditState {
+  const legacyPath = path.join(mindRoot, LEGACY_JSONL_FILE);
+  if (!fs.existsSync(legacyPath)) return state;
+
+  let raw = '';
+  try {
+    raw = fs.readFileSync(legacyPath, 'utf-8');
+  } catch {
+    return state;
+  }
+
+  const lines = parseJsonLines(raw);
+  const importedCount = state.legacy?.jsonlImportedCount ?? 0;
+  if (lines.length <= importedCount) {
+    if (lines.length > 0) removeLegacyFile(legacyPath);
+    return state;
+  }
+
+  const incoming = lines.slice(importedCount);
+  const imported = incoming.map((entry, idx) => toEvent(entry, 'legacy_agent_log_jsonl_import', idx));
+  const merged = [...state.events, ...imported]
+    .sort((a, b) => new Date(b.ts).getTime() - new Date(a.ts).getTime())
+    .slice(0, MAX_EVENTS);
+
+  const next = {
+    ...state,
+    events: merged,
+    legacy: {
+      mdImportedCount: state.legacy?.mdImportedCount ?? 0,
+      jsonlImportedCount: lines.length,
+      lastImportedAt: nowIso(),
+    },
+  };
+  removeLegacyFile(legacyPath);
+  return next;
+}
+
+function loadState(mindRoot: string): AgentAuditState {
+  const base = readState(mindRoot);
+  const mdMigrated = importLegacyMdIfNeeded(mindRoot, base);
+  const migrated = importLegacyJsonlIfNeeded(mindRoot, mdMigrated);
+  const changed =
+    base.events.length !== migrated.events.length ||
+    (base.legacy?.mdImportedCount ?? 0) !== (migrated.legacy?.mdImportedCount ?? 0) ||
+    (base.legacy?.jsonlImportedCount ?? 0) !== (migrated.legacy?.jsonlImportedCount ?? 0);
+  if (changed) writeState(mindRoot, migrated);
+  return migrated;
+}
+
+export function appendAgentAuditEvent(mindRoot: string, input: AgentAuditInput): AgentAuditEvent {
+  const state = loadState(mindRoot);
+  const event: AgentAuditEvent = {
+    id: `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`,
+    ts: validIso(input.ts),
+    tool: input.tool,
+    params: input.params && typeof input.params === 'object' ? input.params : {},
+    result: input.result === 'error' ? 'error' : 'ok',
+    message: normalizeMessage(input.message),
+    durationMs: typeof input.durationMs === 'number' ? input.durationMs : undefined,
+    op: 'append',
+  };
+  state.events.unshift(event);
+  if (state.events.length > MAX_EVENTS) state.events = state.events.slice(0, MAX_EVENTS);
+  writeState(mindRoot, state);
+  return event;
+}
+
+export function listAgentAuditEvents(mindRoot: string, limit = 100): AgentAuditEvent[] {
+  const state = loadState(mindRoot);
+  const safeLimit = Math.max(1, Math.min(limit, 1000));
+  return state.events.slice(0, safeLimit);
+}
+
+export function parseAgentAuditJsonLines(raw: string): AgentAuditInput[] {
+  return parseJsonLines(raw).map((entry) => ({
+    ts: validIso(entry.ts),
+    tool: typeof entry.tool === 'string' && entry.tool.trim() ? entry.tool.trim() : 'unknown-tool',
+    params: entry.params && typeof entry.params === 'object' ? entry.params : {},
+    result: entry.result === 'error' ? 'error' : 'ok',
+    message: normalizeMessage(entry.message),
+    durationMs: typeof entry.durationMs === 'number' ? entry.durationMs : undefined,
+  }));
+}
+

package/app/lib/core/index.ts

@@ -78,3 +78,14 @@ export type {
   ContentChangeSummary,
   ContentChangeSource,
 } from './content-changes';
+
+// Agent audit log
+export {
+  appendAgentAuditEvent,
+  listAgentAuditEvents,
+  parseAgentAuditJsonLines,
+} from './agent-audit-log';
+export type {
+  AgentAuditEvent,
+  AgentAuditInput,
+} from './agent-audit-log';

package/app/lib/fs.ts

@@ -57,6 +57,14 @@ interface FileTreeCache {
 let _cache: FileTreeCache | null = null;
 const CACHE_TTL_MS = 5_000; // 5 seconds
 
+let _treeVersion = 0;
+
+/** Monotonically increasing counter — bumped on every file mutation so the
+ *  client can cheaply detect changes without rebuilding the full tree. */
+export function getTreeVersion(): number {
+  return _treeVersion;
+}
+
 function isCacheValid(): boolean {
   return _cache !== null && (Date.now() - _cache.timestamp) < CACHE_TTL_MS;
 }
@@ -65,6 +73,7 @@ function isCacheValid(): boolean {
 export function invalidateCache(): void {
   _cache = null;
   _searchIndex = null;
+  _treeVersion++;
   invalidateSearchIndex();
 }