clawmini 0.0.8 → 0.0.9

package/src/shared/adapters/turn-log.ts

@@ -0,0 +1,357 @@
+import type { ChatMessage } from '../chats.js';
+
+export interface TurnLogEntry {
+  timestamp: string;
+  kind: 'tool' | 'subagent' | 'policy' | 'system';
+  summary: string;
+  rawLength: number;
+  subagentId?: string;
+  messageRole: string;
+}
+
+export interface FormatOpts {
+  maxToolPreview?: number;
+  /**
+   * Reference time for rendering relative timestamps (e.g. `0s`, `1m5s`).
+   * When omitted, timestamps fall back to wall-clock `HH:MM:SS`.
+   */
+  turnStartedAt?: string;
+}
+
+export interface CondenseOpts {
+  maxChars: number;
+}
+
+export type CondenseResult =
+  | { kind: 'fits'; text: string }
+  | { kind: 'rollover'; finalText: string; carryEntries: TurnLogEntry[] };
+
+const DEFAULT_MAX_TOOL_PREVIEW = 400;
+const TRUNCATED_SUFFIX = '…[truncated]';
+const ROLLOVER_MARKER = '• …log continues';
+
+function pad2(n: number): string {
+  return n < 10 ? `0${n}` : String(n);
+}
+
+function formatRelative(deltaMs: number): string {
+  const sec = Math.max(0, Math.floor(deltaMs / 1000));
+  if (sec < 60) return `${sec}s`;
+  const m = Math.floor(sec / 60);
+  const s = sec % 60;
+  return s === 0 ? `${m}m` : `${m}m${s}s`;
+}
+
+function formatTimestamp(iso: string, turnStartedAt?: string): string {
+  if (turnStartedAt) {
+    const start = new Date(turnStartedAt).getTime();
+    const now = iso ? new Date(iso).getTime() : Date.now();
+    if (!Number.isNaN(start) && !Number.isNaN(now)) {
+      return formatRelative(now - start);
+    }
+  }
+  const d = iso ? new Date(iso) : new Date();
+  const valid = !Number.isNaN(d.getTime()) ? d : new Date();
+  return `${pad2(valid.getHours())}:${pad2(valid.getMinutes())}:${pad2(valid.getSeconds())}`;
+}
+
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+
+function shortSubagentId(id: string): string {
+  // UUIDs are visual noise; the first hex segment is enough to disambiguate.
+  // User-supplied ids (e.g. `hello-sub`) are typically short already.
+  return UUID_RE.test(id) ? id.slice(0, 8) : id;
+}
+
+interface ToolPrincipal {
+  verb: string;
+  arg: string;
+}
+
+/**
+ * Extract a (verb, principal-arg) pair from a tool message so the turn log
+ * can render `read: foo.md` instead of `read_file({ "file_path": "foo.md" })`.
+ * Unknown tool names fall back to `<name>: <stringified-payload>` so we don't
+ * silently lose information.
+ */
+function extractToolPrincipal(name: string, payload: unknown): ToolPrincipal {
+  const p = (payload ?? {}) as Record<string, unknown>;
+  const str = (v: unknown) => (v == null ? '' : String(v));
+
+  switch (name) {
+    case 'read_file':
+    case 'Read':
+      return { verb: 'read', arg: str(p.file_path ?? p.path) };
+    case 'write_file':
+    case 'create_file':
+    case 'Write':
+      return { verb: 'write', arg: str(p.file_path ?? p.path) };
+    case 'edit_file':
+    case 'Edit':
+      return { verb: 'edit', arg: str(p.file_path ?? p.path) };
+    case 'run_shell_command':
+    case 'shell':
+    case 'Bash':
+      return { verb: 'shell', arg: str(p.command) };
+    case 'activate_skill':
+    case 'Skill':
+      return { verb: 'skill', arg: str(p.name ?? p.skill) };
+    case 'glob':
+    case 'Glob':
+      return { verb: 'glob', arg: str(p.pattern) };
+    case 'grep':
+    case 'Grep':
+      return { verb: 'grep', arg: str(p.pattern) };
+    case 'web_fetch':
+    case 'WebFetch':
+      return { verb: 'fetch', arg: str(p.url) };
+  }
+
+  const arg = payload === undefined || payload === null ? '' : JSON.stringify(payload);
+  return { verb: name, arg };
+}
+
+function statusSigil(status: 'completed' | 'failed'): string {
+  return status === 'completed' ? '✅' : '❌';
+}
+
+/** Emoji for messages crossing the subagent boundary. */
+const SUBAGENT_TO = '👉';
+const SUBAGENT_FROM = '👈';
+
+/**
+ * Emoji that stands in for a known tool verb. When present, it replaces the
+ * verb word entirely (`🐚 sleep 20` instead of `shell: sleep 20`). Unknown
+ * tools fall through to the `<name>: <arg>` form, preserving accessibility.
+ */
+const VERB_EMOJI: Record<string, string> = {
+  read: '📖',
+  write: '✍️',
+  edit: '✏️',
+  shell: '🧑‍💻',
+  skill: '📚',
+  glob: '📁',
+  grep: '🔎',
+  fetch: '🌐',
+};
+
+const SUBAGENT_MARKER = '🤖';
+
+/** Emoji rendered on the turn's opening entry (posted when the turn starts). */
+export const TURN_START_EMOJI = '▶️';
+
+/**
+ * Entries produced *inside* a subagent (a tool call, policy, system event
+ * with `subagentId` set) need a marker so the reader knows the activity
+ * happened inside the delegated turn. Boundary events (prompt, reply, status)
+ * already name the subagent via 👉/👈/✅, so they're excluded.
+ */
+function needsSubagentMarker(entry: TurnLogEntry): boolean {
+  if (!entry.subagentId) return false;
+  return (
+    entry.messageRole !== 'user' &&
+    entry.messageRole !== 'agent' &&
+    entry.messageRole !== 'subagent_status'
+  );
+}
+
+function truncate(s: string, max: number): string {
+  if (s.length <= max) return s;
+  const budget = Math.max(0, max - TRUNCATED_SUFFIX.length);
+  return s.slice(0, budget) + TRUNCATED_SUFFIX;
+}
+
+function sanitize(s: string): string {
+  return s.replace(/\s*\r?\n\s*/g, ' ').trim();
+}
+
+function renderEntry(entry: TurnLogEntry): string {
+  const prefix = needsSubagentMarker(entry)
+    ? `${SUBAGENT_MARKER} ${shortSubagentId(entry.subagentId!)} `
+    : '';
+  return `• ${entry.timestamp}  ${prefix}${entry.summary}`;
+}
+
+/**
+ * Build the first entry posted into a turn's activity log so the thread
+ * appears as soon as `turnStarted` fires, rather than waiting for the first
+ * real event.
+ */
+export function buildTurnStartEntry(): TurnLogEntry {
+  const summary = `${TURN_START_EMOJI} Started processing…`;
+  return {
+    timestamp: '0s',
+    kind: 'system',
+    summary,
+    rawLength: summary.length,
+    messageRole: 'turn_start',
+  };
+}
+
+export function formatTurnLogEntry(
+  message: ChatMessage,
+  opts: FormatOpts = {}
+): TurnLogEntry | null {
+  const maxToolPreview = opts.maxToolPreview ?? DEFAULT_MAX_TOOL_PREVIEW;
+  const timestamp = formatTimestamp(message.timestamp, opts.turnStartedAt);
+
+  if (message.role === 'user' || message.role === 'agent') {
+    if (!message.subagentId) return null;
+    // Subagent prompts and final replies are part of the parent turn's
+    // activity: the prompt shows what the subagent was told to do, the reply
+    // shows what it produced. Render them in the log so the reader can follow
+    // the orchestration without switching context.
+    const direction = message.role === 'user' ? SUBAGENT_TO : SUBAGENT_FROM;
+    const content = sanitize(message.content);
+    const id = shortSubagentId(message.subagentId);
+    const summary = `${direction} ${id}: ${truncate(content, maxToolPreview)}`;
+    return {
+      timestamp,
+      kind: 'subagent',
+      summary,
+      rawLength: content.length,
+      messageRole: message.role,
+      subagentId: message.subagentId,
+    };
+  }
+
+  if (message.role === 'tool') {
+    const { verb, arg } = extractToolPrincipal(message.name, message.payload);
+    const cleanArg = sanitize(arg);
+    const emoji = VERB_EMOJI[verb];
+    const argPreview = cleanArg ? truncate(cleanArg, maxToolPreview) : '';
+    let summary: string;
+    if (emoji) {
+      summary = argPreview ? `${emoji} ${argPreview}` : emoji;
+    } else {
+      summary = argPreview ? `${verb}: ${argPreview}` : verb;
+    }
+    const entry: TurnLogEntry = {
+      timestamp,
+      kind: 'tool',
+      summary,
+      rawLength: cleanArg.length,
+      messageRole: message.role,
+    };
+    if (message.subagentId) entry.subagentId = message.subagentId;
+    return entry;
+  }
+
+  if (message.role === 'subagent_status') {
+    const id = shortSubagentId(message.subagentId);
+    const summary = `${statusSigil(message.status)} ${id}`;
+    const entry: TurnLogEntry = {
+      timestamp,
+      kind: 'subagent',
+      summary,
+      rawLength: summary.length,
+      messageRole: message.role,
+      subagentId: message.subagentId,
+    };
+    return entry;
+  }
+
+  if (message.role === 'policy') {
+    const body = `${message.commandName} ${message.args.join(' ')}`.trim();
+    const summary = `policy ${message.status}: ${body}`;
+    const entry: TurnLogEntry = {
+      timestamp,
+      kind: 'policy',
+      summary: truncate(sanitize(summary), maxToolPreview),
+      rawLength: summary.length,
+      messageRole: message.role,
+    };
+    if (message.subagentId) entry.subagentId = message.subagentId;
+    return entry;
+  }
+
+  if (message.role === 'system') {
+    // subagent_update is the wake-up signal that re-enters the parent agent
+    // after an async subagent completes. Its content is a `<notification>`
+    // envelope — internal orchestration the reader doesn't need. The ✅ from
+    // subagent_status already conveys completion, and the parent's follow-up
+    // reply shows the response.
+    if (message.event === 'subagent_update') return null;
+    const content = sanitize(message.content || '');
+    const summary = content ? `${message.event}: ${content}` : message.event;
+    const entry: TurnLogEntry = {
+      timestamp,
+      kind: 'system',
+      summary: truncate(summary, maxToolPreview),
+      rawLength: summary.length,
+      messageRole: message.role,
+    };
+    if (message.subagentId) entry.subagentId = message.subagentId;
+    return entry;
+  }
+
+  if (message.role === 'command') {
+    // The raw shell command (usually the agent template wrapping
+    // $CLAW_CLI_MESSAGE) isn't informative to a reader skimming the log;
+    // tool calls and subagent events already describe what the agent did.
+    return null;
+  }
+
+  if (message.role === 'legacy_log') {
+    const content = sanitize(message.content);
+    const summary = content ? `log: ${content}` : 'log';
+    const entry: TurnLogEntry = {
+      timestamp,
+      kind: 'system',
+      summary: truncate(summary, maxToolPreview),
+      rawLength: content.length,
+      messageRole: message.role,
+    };
+    if (message.subagentId) entry.subagentId = message.subagentId;
+    return entry;
+  }
+
+  return null;
+}
+
+function joinLines(entries: TurnLogEntry[]): string {
+  return entries.map(renderEntry).join('\n');
+}
+
+export function condenseTurnLog(
+  entries: readonly TurnLogEntry[],
+  opts: CondenseOpts
+): CondenseResult {
+  const snapshot = entries.slice();
+  if (snapshot.length === 0) return { kind: 'fits', text: '' };
+
+  const fullText = joinLines(snapshot);
+  if (fullText.length <= opts.maxChars) return { kind: 'fits', text: fullText };
+
+  const markerReserve = ROLLOVER_MARKER.length + 1;
+  const budget = Math.max(0, opts.maxChars - markerReserve);
+
+  const kept: TurnLogEntry[] = [];
+  let runningLength = 0;
+  for (let i = 0; i < snapshot.length; i++) {
+    const line = renderEntry(snapshot[i]!);
+    const next = runningLength === 0 ? line.length : runningLength + 1 + line.length;
+    if (next > budget) {
+      if (kept.length === 0) {
+        // Single entry's line is larger than the per-message budget: hard-
+        // truncate its rendered form so we don't get stuck in a "same carry"
+        // rollover loop. The continuation marker is baked into the truncated
+        // text rather than appended, so the reader still sees the `…` signal.
+        const truncatedLine = truncate(line, opts.maxChars);
+        return {
+          kind: 'rollover',
+          finalText: truncatedLine,
+          carryEntries: snapshot.slice(i + 1),
+        };
+      }
+      const carryEntries = snapshot.slice(i);
+      const finalText = `${joinLines(kept)}\n${ROLLOVER_MARKER}`;
+      return { kind: 'rollover', finalText, carryEntries };
+    }
+    runningLength = next;
+    kept.push(snapshot[i]!);
+  }
+
+  // Should not reach here; fallback.
+  return { kind: 'fits', text: fullText };
+}

package/src/shared/agent-utils.ts

@@ -4,7 +4,8 @@ import {
   applyTemplateToAgent,
   readChatSettings,
   writeChatSettings,
-  copyAgentSkills,
+  refreshAgentSkills,
+  getAgent,
 } from './workspace.js';
 import { createChat, listChats } from './chats.js';
 
@@ -12,17 +13,23 @@ export async function createAgentWithChat(
   agentId: string,
   agentData: Agent,
   template?: string,
-  startDir = process.cwd()
+  startDir = process.cwd(),
+  opts: { fork?: boolean; force?: boolean } = {}
 ): Promise<void> {
   await writeAgentSettings(agentId, agentData, startDir);
 
   if (template) {
-    await applyTemplateToAgent(agentId, template, agentData, startDir);
+    await applyTemplateToAgent(agentId, template, agentData, startDir, opts);
   }
 
   try {
-    await copyAgentSkills(agentId, startDir);
-    console.log(`Copied skills to agent ${agentId}.`);
+    const resolved = await getAgent(agentId, startDir);
+    if (resolved?.skillsDir === null) {
+      console.log(`Skipping skills for agent ${agentId} (skillsDir is null).`);
+    } else if (resolved) {
+      await refreshAgentSkills(agentId, resolved, startDir, { firstInstall: true });
+      console.log(`Installed skills for agent ${agentId}.`);
+    }
   } catch (err) {
     console.warn(
       `Warning: Failed to copy skills to agent ${agentId}: ${err instanceof Error ? err.message : String(err)}`

package/src/shared/chats.test.ts

@@ -58,6 +58,7 @@ describe('chats utilities', () => {
       role: 'user',
       content: 'Hello',
       timestamp: new Date().toISOString(),
+      sessionId: undefined,
     };
 
     const msg2: CommandLogMessage = {
@@ -71,6 +72,7 @@ describe('chats utilities', () => {
       command: 'echo output',
       cwd: '/tmp',
       exitCode: 0,
+      sessionId: undefined,
     };
 
     const msg3: CommandLogMessage = {
@@ -84,6 +86,7 @@ describe('chats utilities', () => {
       command: 'router',
       cwd: '/tmp',
       exitCode: 0,
+      sessionId: undefined,
     };
 
     await appendMessage('chat1', msg1, TEST_DIR);
@@ -129,6 +132,7 @@ describe('chats utilities', () => {
       role: 'user',
       content: `Message ${i + 1}`,
       timestamp: new Date().toISOString(),
+      sessionId: undefined,
     }));
 
     for (const msg of msgs) {

package/src/shared/chats.ts

@@ -14,6 +14,8 @@ export interface BaseMessage {
   content: string;
   timestamp: string;
   subagentId?: string;
+  sessionId: string | undefined;
+  turnId?: string;
 }
 
 export interface UserMessage extends BaseMessage {
@@ -48,6 +50,12 @@ export interface SystemMessage extends BaseMessage {
   role: 'system';
   event: 'cron' | 'policy_approved' | 'policy_rejected' | 'subagent_update' | 'router' | 'other';
   messageId?: string;
+  /**
+   * Populated on `event === 'cron'` with the CronJob id that fired. Used by
+   * adapters (gchat `visibility.jobs: 'header'`) to render a terse header
+   * instead of the agent-facing prompt.
+   */
+  jobId?: string;
 }
 
 export interface ToolMessage extends BaseMessage {
@@ -70,6 +78,7 @@ export interface SubagentStatusMessage extends BaseMessage {
   role: 'subagent_status';
   subagentId: string;
   status: 'completed' | 'failed';
+  turnId?: string;
 }
 
 export interface LegacyLogMessage extends BaseMessage {

package/src/shared/config.ts

@@ -1,5 +1,13 @@
 import { z } from 'zod';
 
+const PolicyDefinitionSchema = z.looseObject({
+  description: z.string().optional(),
+  command: z.string(),
+  args: z.array(z.string()).optional(),
+  allowHelp: z.boolean().optional(),
+  autoApprove: z.boolean().optional(),
+});
+
 export const FallbackSchema = z.looseObject({
   commands: z
     .looseObject({
@@ -15,6 +23,7 @@ export const FallbackSchema = z.looseObject({
 });
 
 export const AgentSchema = z.looseObject({
+  extends: z.string().optional(),
   commands: z
     .looseObject({
       new: z.string().optional(),
@@ -27,8 +36,11 @@ export const AgentSchema = z.looseObject({
   apiUrlEnvVar: z.string().optional(),
   env: z.record(z.string(), z.union([z.string(), z.boolean()])).optional(),
   subagentEnv: z.record(z.string(), z.union([z.string(), z.boolean()])).optional(),
+  modelShorthands: z.record(z.string(), z.string()).optional(),
   directory: z.string().optional(),
-  skillsDir: z.string().optional(),
+  // `null` explicitly disables skill install/refresh for this agent.
+  // `undefined` (omitted) falls back to the template's value or `.agents/skills`.
+  skillsDir: z.string().nullable().optional(),
   fallbacks: z.array(FallbackSchema).optional(),
   files: z.string().default('./attachments').optional(),
 });
@@ -116,13 +128,16 @@ export const AgentSessionSettingsSchema = z.looseObject({
 export type AgentSessionSettings = z.infer<typeof AgentSessionSettingsSchema>;
 
 export const EnvironmentSchema = z.looseObject({
+  extends: z.string().optional(),
   init: z.string().optional(),
   up: z.string().optional(),
   down: z.string().optional(),
   prefix: z.string().optional(),
   envFormat: z.string().optional(),
   exportLiteTo: z.string().optional(),
+  baseDir: z.string().optional(),
   env: z.record(z.string(), z.union([z.string(), z.boolean()])).optional(),
+  policies: z.record(z.string(), PolicyDefinitionSchema).optional(),
 });
 
 export type Environment = z.infer<typeof EnvironmentSchema>;

package/src/shared/lite.ts

@@ -1,9 +1,20 @@
 import fs from 'node:fs/promises';
 import path from 'node:path';
+import { createHash } from 'node:crypto';
 import { fileURLToPath } from 'node:url';
 import { readSettings, readEnvironment, getWorkspaceRoot } from './workspace.js';
 import type { Environment } from './config.js';
 
+const LITE_MARKER = 'clawmini-lite';
+
+function sha256(content: string): string {
+  return createHash('sha256').update(content).digest('hex');
+}
+
+function looksLikeLiteScript(content: string): boolean {
+  return content.startsWith('#!') && content.includes(LITE_MARKER);
+}
+
 export async function resolveCompiledScript(scriptName: string, metaUrl: string): Promise<string> {
   const __dirname = path.dirname(fileURLToPath(metaUrl));
   const filename = scriptName.endsWith('.mjs') ? scriptName : `${scriptName}.mjs`;
@@ -77,6 +88,63 @@ export async function writeLiteScript(outPath: string): Promise<string> {
   return finalPath;
 }
 
+async function resolveLiteTargetPath(outPath: string): Promise<string> {
+  const isProbablyFile =
+    path.extname(outPath) === '.js' ||
+    path.extname(outPath) === '.mjs' ||
+    path.basename(outPath) === 'clawmini-lite';
+
+  try {
+    const stat = await fs.stat(outPath);
+    if (stat.isDirectory()) {
+      return path.join(outPath, 'clawmini-lite.js');
+    }
+    return outPath;
+  } catch {
+    if (isProbablyFile) return outPath;
+    // No extension and path doesn't yet exist — treat as a directory target.
+    return path.join(outPath, 'clawmini-lite.js');
+  }
+}
+
+// Content-hashed write that refuses to clobber an arbitrary user file at the
+// export path. Returns:
+//   - 'written' when the file was created or updated
+//   - 'unchanged' when the on-disk content already matches (no mtime touch)
+//   - 'refused' when the existing file looks like it isn't a clawmini-lite
+export async function refreshLiteAt(
+  outPath: string,
+  opts: { label?: string } = {}
+): Promise<{ status: 'written' | 'unchanged' | 'refused'; path: string }> {
+  const content = await getLiteScriptContent();
+  const finalPath = await resolveLiteTargetPath(outPath);
+
+  let existing: string | null = null;
+  try {
+    existing = await fs.readFile(finalPath, 'utf8');
+  } catch {
+    // missing — write below
+  }
+
+  if (existing !== null) {
+    if (sha256(existing) === sha256(content)) {
+      return { status: 'unchanged', path: finalPath };
+    }
+    if (!looksLikeLiteScript(existing)) {
+      const label = opts.label ? ` (${opts.label})` : '';
+      console.warn(
+        `Refusing to overwrite ${finalPath}${label}: existing file is not a clawmini-lite script`
+      );
+      return { status: 'refused', path: finalPath };
+    }
+  }
+
+  const dir = path.dirname(finalPath);
+  await fs.mkdir(dir, { recursive: true });
+  await fs.writeFile(finalPath, content, { mode: 0o755 });
+  return { status: 'written', path: finalPath };
+}
+
 export async function exportLiteToEnvironment(
   envName: string,
   envConfig: Environment,
@@ -98,8 +166,14 @@ export async function exportLiteToEnvironment(
   }
 
   try {
-    const writtenPath = await writeLiteScript(finalExportPath);
-    console.log(`Successfully exported clawmini-lite to ${writtenPath} (Environment: ${envName})`);
+    const result = await refreshLiteAt(finalExportPath, { label: `Environment: ${envName}` });
+    if (result.status === 'written') {
+      console.log(
+        `Successfully exported clawmini-lite to ${result.path} (Environment: ${envName})`
+      );
+    } else if (result.status === 'refused') {
+      return false;
+    }
     return true;
   } catch (err) {
     console.error(

package/src/shared/policies.ts

@@ -6,10 +6,35 @@ export interface PolicyDefinition {
   autoApprove?: boolean;
 }
 
+// Resolved policy config: built-ins merged in, `false` overrides stripped.
+// This is what every consumer should see.
 export interface PolicyConfig {
   policies: Record<string, PolicyDefinition>;
 }
 
+// On-disk shape: `false` opts a built-in out, a definition opts in / overrides.
+export interface PolicyConfigFile {
+  policies: Record<string, PolicyDefinition | false>;
+}
+
+export const BUILTIN_POLICY_SCRIPTS_DIR = '.clawmini/policy-scripts';
+
+export const BUILTIN_POLICIES: Record<string, PolicyDefinition> = {
+  'manage-policies': {
+    description:
+      'Add, update, or remove clawmini policies (subcommands: add, update, remove). Reads are unrestricted via `requests show`.',
+    command: `./${BUILTIN_POLICY_SCRIPTS_DIR}/manage-policies.js`,
+    allowHelp: true,
+    autoApprove: false,
+  },
+  'run-host': {
+    description: 'Run an arbitrary shell command on the host via `sh -c`',
+    command: `./${BUILTIN_POLICY_SCRIPTS_DIR}/run-host.js`,
+    allowHelp: true,
+    autoApprove: false,
+  },
+};
+
 export type RequestState = 'Pending' | 'Approved' | 'Rejected';
 
 export interface PolicyRequest {
@@ -17,6 +42,7 @@ export interface PolicyRequest {
   commandName: string;
   args: string[];
   fileMappings: Record<string, string>;
+  cwd?: string;
   state: RequestState;
   createdAt: number;
   rejectionReason?: string;