gitclaw 0.3.1 → 0.4.1

package/dist/index.js

@@ -4,7 +4,7 @@ import { Agent } from "@mariozechner/pi-agent-core";
 import { loadAgent } from "./loader.js";
 import { createBuiltinTools } from "./tools/index.js";
 import { createSandboxContext } from "./sandbox.js";
-import { expandSkillCommand } from "./skills.js";
+import { expandSkillCommand, refreshSkills } from "./skills.js";
 import { loadHooksConfig, runHooks, wrapToolWithHooks } from "./hooks.js";
 import { loadDeclarativeTools } from "./tool-loader.js";
 import { AuditLogger, isAuditEnabled } from "./audit.js";
@@ -13,6 +13,7 @@ import { readFile, mkdir, writeFile, access } from "fs/promises";
 import { join, resolve } from "path";
 import { execSync } from "child_process";
 import { initLocalSession } from "./session.js";
+import { startVoiceServer } from "./voice/server.js";
 // ANSI helpers
 const dim = (s) => `\x1b[2m${s}\x1b[0m`;
 const bold = (s) => `\x1b[1m${s}\x1b[0m`;
@@ -30,6 +31,7 @@ function parseArgs(argv) {
     let repo;
     let pat;
     let session;
+    let voice;
     for (let i = 0; i < args.length; i++) {
         switch (args[i]) {
             case "--model":
@@ -68,6 +70,16 @@ function parseArgs(argv) {
             case "--session":
                 session = args[++i];
                 break;
+            case "--voice":
+            case "-v":
+                // Accept optional backend name: --voice, --voice openai, --voice gemini
+                if (args[i + 1] && !args[i + 1].startsWith("-")) {
+                    voice = args[++i];
+                }
+                else {
+                    voice = "openai";
+                }
+                break;
             default:
                 if (!args[i].startsWith("-")) {
                     prompt = args[i];
@@ -75,7 +87,7 @@ function parseArgs(argv) {
                 break;
         }
     }
-    return { model, dir, prompt, env, sandbox, sandboxRepo, sandboxToken, repo, pat, session };
+    return { model, dir, prompt, env, sandbox, sandboxRepo, sandboxToken, repo, pat, session, voice };
 }
 function handleEvent(event, hooksConfig, agentDir, sessionId, auditLogger) {
     switch (event.type) {
@@ -236,7 +248,7 @@ async function ensureRepo(dir, model) {
     return absDir;
 }
 async function main() {
-    const { model, dir: rawDir, prompt, env, sandbox: useSandbox, sandboxRepo, sandboxToken, repo, pat, session: sessionBranch } = parseArgs(process.argv);
+    const { model, dir: rawDir, prompt, env, sandbox: useSandbox, sandboxRepo, sandboxToken, repo, pat, session: sessionBranch, voice } = parseArgs(process.argv);
     // If --repo is given, derive a default dir from the repo URL (skip interactive prompt)
     let dir = rawDir;
     let localSession;
@@ -295,6 +307,46 @@ async function main() {
     else {
         dir = resolve(dir);
     }
+    // Voice mode
+    if (voice) {
+        let adapterBackend;
+        let apiKey;
+        if (voice === "gemini") {
+            adapterBackend = "gemini-live";
+            apiKey = process.env.GEMINI_API_KEY;
+            if (!apiKey) {
+                console.error(red("Error: GEMINI_API_KEY is required for --voice gemini"));
+                process.exit(1);
+            }
+        }
+        else {
+            adapterBackend = "openai-realtime";
+            apiKey = process.env.OPENAI_API_KEY;
+            if (!apiKey) {
+                console.error(red("Error: OPENAI_API_KEY is required for --voice mode"));
+                process.exit(1);
+            }
+        }
+        const cleanup = await startVoiceServer({
+            adapter: adapterBackend,
+            adapterConfig: { apiKey },
+            agentDir: dir,
+            model,
+            env,
+        });
+        let stopping = false;
+        process.on("SIGINT", () => {
+            if (stopping) {
+                // Second Ctrl+C — force exit immediately
+                process.exit(1);
+            }
+            stopping = true;
+            console.log("\nDisconnecting...");
+            cleanup().finally(() => process.exit(0));
+        });
+        // Keep process alive
+        return;
+    }
     let loaded;
     try {
         loaded = await loadAgent(dir, model, env);
@@ -356,6 +408,7 @@ async function main() {
         dir,
         timeout: manifest.runtime.timeout,
         sandbox: sandboxCtx,
+        gitagentDir,
     });
     // Load declarative tools from tools/*.yaml (Phase 2.2)
     const declarativeTools = await loadDeclarativeTools(agentDir);
@@ -401,7 +454,7 @@ async function main() {
     if (loaded.subAgents.length > 0) {
         console.log(dim(`Agents: ${loaded.subAgents.map((a) => a.name).join(", ")}`));
     }
-    console.log(dim('Type /skills to list skills, /memory to view memory, /quit to exit\n'));
+    console.log(dim('Type /skills, /tasks, /learned, /memory, /quit\n'));
     // Single-shot mode
     if (prompt) {
         try {
@@ -466,12 +519,51 @@ async function main() {
                 return;
             }
             if (trimmed === "/skills") {
-                if (skills.length === 0) {
+                // Refresh skills to pick up any newly learned ones
+                const currentSkills = await refreshSkills(dir);
+                if (currentSkills.length === 0) {
                     console.log(dim("No skills installed."));
                 }
                 else {
-                    for (const s of skills) {
-                        console.log(`  ${bold(s.name)} — ${dim(s.description)}`);
+                    for (const s of currentSkills) {
+                        const conf = s.confidence !== undefined ? dim(` [confidence: ${s.confidence}]`) : "";
+                        console.log(`  ${bold(s.name)} — ${dim(s.description)}${conf}`);
+                    }
+                }
+                ask();
+                return;
+            }
+            if (trimmed === "/tasks") {
+                try {
+                    const tasksRaw = await readFile(join(gitagentDir, "learning", "tasks.json"), "utf-8");
+                    const tasksData = JSON.parse(tasksRaw);
+                    const active = (tasksData.tasks || []).filter((t) => t.status === "active");
+                    if (active.length === 0) {
+                        console.log(dim("No active tasks."));
+                    }
+                    else {
+                        for (const t of active) {
+                            console.log(`  ${bold(t.id.slice(0, 8))} — ${t.objective} (${t.steps.length} steps, attempt #${t.attempts})`);
+                        }
+                    }
+                }
+                catch {
+                    console.log(dim("No tasks recorded yet."));
+                }
+                ask();
+                return;
+            }
+            if (trimmed === "/learned") {
+                const currentSkills = await refreshSkills(dir);
+                const learned = currentSkills.filter((s) => s.confidence !== undefined);
+                if (learned.length === 0) {
+                    console.log(dim("No learned skills yet."));
+                }
+                else {
+                    for (const s of learned) {
+                        const usage = s.usage_count ?? 0;
+                        const ratio = `${s.success_count ?? 0}/${(s.success_count ?? 0) + (s.failure_count ?? 0)}`;
+                        console.log(`  ${bold(s.name)} — confidence: ${s.confidence}, usage: ${usage}, success: ${ratio}`);
                     }
                 }
                 ask();

package/dist/learning/reinforcement.d.ts

@@ -0,0 +1,11 @@
+export interface SkillStats {
+    confidence: number;
+    usage_count: number;
+    success_count: number;
+    failure_count: number;
+    negative_examples: string[];
+}
+export declare function adjustConfidence(current: SkillStats, outcome: "success" | "failure" | "partial", failureReason?: string): SkillStats;
+export declare function loadSkillStats(skillDir: string): Promise<SkillStats>;
+export declare function saveSkillStats(skillDir: string, stats: SkillStats): Promise<void>;
+export declare function isSkillFlagged(stats: SkillStats): boolean;

package/dist/learning/reinforcement.js

@@ -0,0 +1,91 @@
+import { readFile, writeFile } from "fs/promises";
+import { join } from "path";
+import yaml from "js-yaml";
+const MAX_NEGATIVE_EXAMPLES = 10;
+const DEFAULT_STATS = {
+    confidence: 1.0,
+    usage_count: 0,
+    success_count: 0,
+    failure_count: 0,
+    negative_examples: [],
+};
+// ── Confidence math ─────────────────────────────────────────────────────
+export function adjustConfidence(current, outcome, failureReason) {
+    const stats = { ...current };
+    stats.usage_count++;
+    switch (outcome) {
+        case "success":
+            // Asymptotic to 1.0: conf + 0.1 * (1 - conf)
+            stats.confidence = Math.min(1.0, stats.confidence + 0.1 * (1 - stats.confidence));
+            stats.success_count++;
+            break;
+        case "failure":
+            // 2x penalty (asymmetric loss)
+            stats.confidence = Math.max(0.0, stats.confidence - 0.2);
+            stats.failure_count++;
+            if (failureReason) {
+                stats.negative_examples = [
+                    ...stats.negative_examples.slice(-(MAX_NEGATIVE_EXAMPLES - 1)),
+                    failureReason,
+                ];
+            }
+            break;
+        case "partial":
+            stats.confidence = Math.max(0.0, stats.confidence - 0.05);
+            stats.failure_count++;
+            if (failureReason) {
+                stats.negative_examples = [
+                    ...stats.negative_examples.slice(-(MAX_NEGATIVE_EXAMPLES - 1)),
+                    failureReason,
+                ];
+            }
+            break;
+    }
+    // Round to avoid floating-point drift
+    stats.confidence = Math.round(stats.confidence * 100) / 100;
+    return stats;
+}
+// ── SKILL.md frontmatter read/write ─────────────────────────────────────
+function parseFrontmatter(content) {
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+    if (!match) {
+        return { frontmatter: {}, body: content };
+    }
+    const frontmatter = yaml.load(match[1]);
+    return { frontmatter, body: match[2] };
+}
+function serializeFrontmatter(frontmatter, body) {
+    const yamlStr = yaml.dump(frontmatter, { lineWidth: -1, noRefs: true }).trimEnd();
+    return `---\n${yamlStr}\n---\n${body}`;
+}
+export async function loadSkillStats(skillDir) {
+    const skillFile = join(skillDir, "SKILL.md");
+    try {
+        const content = await readFile(skillFile, "utf-8");
+        const { frontmatter } = parseFrontmatter(content);
+        return {
+            confidence: typeof frontmatter.confidence === "number" ? frontmatter.confidence : DEFAULT_STATS.confidence,
+            usage_count: typeof frontmatter.usage_count === "number" ? frontmatter.usage_count : DEFAULT_STATS.usage_count,
+            success_count: typeof frontmatter.success_count === "number" ? frontmatter.success_count : DEFAULT_STATS.success_count,
+            failure_count: typeof frontmatter.failure_count === "number" ? frontmatter.failure_count : DEFAULT_STATS.failure_count,
+            negative_examples: Array.isArray(frontmatter.negative_examples) ? frontmatter.negative_examples : [],
+        };
+    }
+    catch {
+        return { ...DEFAULT_STATS };
+    }
+}
+export async function saveSkillStats(skillDir, stats) {
+    const skillFile = join(skillDir, "SKILL.md");
+    const content = await readFile(skillFile, "utf-8");
+    const { frontmatter, body } = parseFrontmatter(content);
+    frontmatter.confidence = stats.confidence;
+    frontmatter.usage_count = stats.usage_count;
+    frontmatter.success_count = stats.success_count;
+    frontmatter.failure_count = stats.failure_count;
+    frontmatter.negative_examples = stats.negative_examples;
+    await writeFile(skillFile, serializeFrontmatter(frontmatter, body), "utf-8");
+}
+export function isSkillFlagged(stats) {
+    return stats.confidence < 0.4;
+}

package/dist/loader.js

@@ -162,7 +162,7 @@ export async function loadAgent(agentDir, modelFlag, envFlag) {
         parts.push(duties);
     if (agentsMd)
         parts.push(agentsMd);
-    parts.push(`# Memory\n\nYou have a memory file at memory/MEMORY.md. Use the \`memory\` tool to load and save memories. Each save creates a git commit, so your memory has full history. You can also use the \`cli\` tool to run git commands for deeper memory inspection (git log, git diff, git show).`);
+    parts.push(`# Memory\n\nYou have a memory file at memory/MEMORY.md. Use the \`memory\` tool to load and save memories. Each save creates a git commit, so your memory has full history. You can also use the \`cli\` tool to run git commands for deeper memory inspection (git log, git diff, git show).\n\nYour memories define who you are. When you have none, you are newly awakened — curious and eager to understand the person you're talking to. As memories grow, so do you. Save memories proactively when you learn something meaningful about the user.`);
     // Discover and load knowledge
     const knowledge = await loadKnowledge(agentDir);
     const knowledgeBlock = formatKnowledgeForPrompt(knowledge);
@@ -196,6 +196,39 @@ export async function loadAgent(agentDir, modelFlag, envFlag) {
     const complianceBlock = await loadComplianceContext(agentDir);
     if (complianceBlock)
         parts.push(complianceBlock);
+    // Workspace directory — all generated files go here
+    parts.push(`# Workspace Directory
+
+ALL files you create (documents, PDFs, images, spreadsheets, code output, exports, assets, etc.) MUST be written to the \`workspace/\` directory.
+- Create the directory if it doesn't exist: \`workspace/\`
+- Example: \`workspace/report.pdf\`, \`workspace/chart.png\`, \`workspace/data.csv\`
+- NEVER write generated files to the project root, home directory, desktop, or any other location
+- The \`workspace/\` directory is the designated output folder for all user-requested artifacts
+- This rule applies to ALL channels: voice, chat, Telegram, WhatsApp`);
+    // Task learning & skill discovery
+    parts.push(`# Task Learning & Skill Discovery
+
+You have an intelligent learning system. For ANY task the user gives you:
+
+1. FIRST: Call \`task_tracker\` action "begin" with your objective — this searches for existing skills
+2. If a matching skill is found, you MUST load and follow its instructions BEFORE doing anything else
+3. Call \`task_tracker\` action "update" after each significant step
+4. Call \`task_tracker\` action "end" to report the outcome (success/failure/partial)
+
+IMPORTANT: Do NOT skip step 1. Even for tasks that seem simple, always check for skills first.
+Skills encode tested approaches and handle edge cases you might miss with ad-hoc solutions.
+
+On SUCCESS:
+- Call \`skill_learner\` action "evaluate" to check if this approach is worth saving
+- If worthy, call \`skill_learner\` action "crystallize" to save it as a reusable skill
+- The skill will be available in future sessions via /skill:<name>
+
+On FAILURE:
+- Record why it failed. Try a different approach.
+- Failed approaches become negative examples — they won't be repeated
+
+If you used an existing skill, report it via skill_used so confidence adjusts based on the outcome.
+Do NOT track trivial single-command tasks (e.g. "what time is it"). But DO check skills for any task that involves creating, building, or modifying something.`);
     const systemPrompt = parts.join("\n\n");
     // Resolve model — env config model_override > CLI flag > manifest preferred
     const modelStr = envConfig.model_override || modelFlag || manifest.model.preferred;

package/dist/sdk.js

@@ -135,6 +135,7 @@ export function query(options) {
                 dir,
                 timeout: loaded.manifest.runtime.timeout,
                 sandbox: sandboxCtx,
+                gitagentDir: loaded.gitagentDir,
             });
         }
         // Declarative tools from tools/*.yaml
@@ -142,8 +143,11 @@ export function query(options) {
         tools = [...tools, ...declarativeTools];
         // SDK-provided tools
         if (options.tools) {
-            tools = [...tools, ...options.tools.map(toAgentTool)];
+            const converted = options.tools.map(toAgentTool);
+            tools = [...tools, ...converted];
+            console.error(`[sdk] Injected ${converted.length} external tools: ${converted.map(t => t.name).join(", ")}`);
         }
+        console.error(`[sdk] Total tools before filtering: ${tools.length} → ${tools.map(t => t.name).join(", ")}`);
         // Filter by allowlist/denylist
         if (options.allowedTools) {
             const allowed = new Set(options.allowedTools);

package/dist/skills.d.ts

@@ -3,6 +3,10 @@ export interface SkillMetadata {
     description: string;
     directory: string;
     filePath: string;
+    confidence?: number;
+    usage_count?: number;
+    success_count?: number;
+    failure_count?: number;
 }
 export interface ParsedSkill extends SkillMetadata {
     instructions: string;
@@ -12,6 +16,7 @@ export interface ParsedSkill extends SkillMetadata {
 export declare function discoverSkills(agentDir: string): Promise<SkillMetadata[]>;
 export declare function loadSkill(meta: SkillMetadata): Promise<ParsedSkill>;
 export declare function formatSkillsForPrompt(skills: SkillMetadata[]): string;
+export declare function refreshSkills(agentDir: string): Promise<SkillMetadata[]>;
 export declare function expandSkillCommand(input: string, skills: SkillMetadata[]): Promise<{
     expanded: string;
     skillName: string;

package/dist/skills.js

@@ -27,9 +27,13 @@ export async function discoverSkills(agentDir) {
     const entries = await readdir(skillsDir, { withFileTypes: true });
     const skills = [];
     for (const entry of entries) {
-        if (!entry.isDirectory())
+        // Accept both real directories and symlinks pointing to directories
+        if (!entry.isDirectory() && !entry.isSymbolicLink())
             continue;
         const skillDir = join(skillsDir, entry.name);
+        // For symlinks, verify the target is actually a directory
+        if (entry.isSymbolicLink() && !(await dirExists(skillDir)))
+            continue;
         const skillFile = join(skillDir, "SKILL.md");
         let content;
         try {
@@ -53,12 +57,22 @@ export async function discoverSkills(agentDir) {
             console.warn(`Skipping skill "${entry.name}": name must be kebab-case`);
             continue;
         }
-        skills.push({
+        const meta = {
             name,
             description,
             directory: skillDir,
             filePath: skillFile,
-        });
+        };
+        // Parse optional learning fields
+        if (typeof frontmatter.confidence === "number")
+            meta.confidence = frontmatter.confidence;
+        if (typeof frontmatter.usage_count === "number")
+            meta.usage_count = frontmatter.usage_count;
+        if (typeof frontmatter.success_count === "number")
+            meta.success_count = frontmatter.success_count;
+        if (typeof frontmatter.failure_count === "number")
+            meta.failure_count = frontmatter.failure_count;
+        skills.push(meta);
     }
     return skills.sort((a, b) => a.name.localeCompare(b.name));
 }
@@ -76,15 +90,47 @@ export function formatSkillsForPrompt(skills) {
     if (skills.length === 0)
         return "";
     const skillEntries = skills
-        .map((s) => `<skill>\n<name>${s.name}</name>\n<description>${s.description}</description>\n</skill>`)
+        .map((s) => {
+        let entry = `<skill>\n<name>${s.name}</name>\n<description>${s.description}</description>`;
+        entry += `\n<location>skills/${s.name}/SKILL.md</location>`;
+        if (s.confidence !== undefined) {
+            entry += `\n<confidence>${s.confidence}</confidence>`;
+        }
+        entry += "\n</skill>";
+        return entry;
+    })
         .join("\n");
-    return `# Skills
+    return `# Skills — FIRST PRIORITY (MANDATORY)
+
+CRITICAL: You have installed skills that provide specialized capabilities.
+Before attempting ANY task — simple or complex — you MUST check if an installed skill handles it.
+
+## Rules (MUST follow in order)
+1. ALWAYS scan the skill list below BEFORE taking ANY action on a user request
+2. If a skill's description matches or partially matches the task, you MUST load its full
+   instructions using the \`read\` tool: \`skills/<name>/SKILL.md\` — do this BEFORE anything else
+3. Follow the loaded skill instructions EXACTLY — do NOT improvise or use alternative approaches
+4. NEVER use general-purpose workarounds when a skill provides the right tool
+   (e.g., use \`agent-browser open <url>\` NOT \`open -a Safari\`)
+5. If multiple skills could apply, load the most specific one first
+6. Even for seemingly simple tasks, CHECK SKILLS FIRST — skills often handle edge cases
+   and produce higher quality results than ad-hoc approaches
+
+## Enforcement
+- If you skip checking skills and use a raw approach for a task that a skill handles,
+  this is considered a FAILURE. Always check skills first.
+- When calling \`task_tracker\` "begin", if it returns matching skills, you MUST load
+  the top match immediately before proceeding.
 
 <available_skills>
 ${skillEntries}
 </available_skills>
 
-When a task matches a skill, use the \`read\` tool to load \`skills/<name>/SKILL.md\` for full instructions. Scripts within a skill are relative to the skill's directory (e.g., \`skills/<name>/scripts/\`). Use the \`cli\` tool to execute them.`;
+To load a skill's full instructions: read \`skills/<name>/SKILL.md\`
+Scripts within a skill are relative to the skill's directory: \`skills/<name>/scripts/\``;
+}
+export async function refreshSkills(agentDir) {
+    return discoverSkills(agentDir);
 }
 export async function expandSkillCommand(input, skills) {
     const match = input.match(/^\/skill:([a-z0-9-]+)\s*([\s\S]*)$/);
@@ -96,7 +142,12 @@ export async function expandSkillCommand(input, skills) {
     if (!skill)
         return null;
     const parsed = await loadSkill(skill);
-    let expanded = `<skill name="${skillName}" baseDir="${skill.directory}">\n${parsed.instructions}\n</skill>`;
+    let expanded = `<skill name="${skillName}" baseDir="${skill.directory}">
+References are relative to ${skill.directory}.
+
+${parsed.instructions}
+</skill>
+You MUST follow the skill instructions above. Do NOT use general alternatives.`;
     if (args) {
         expanded += `\n\n${args}`;
     }

package/dist/tools/capture-photo.d.ts

@@ -0,0 +1,3 @@
+import type { AgentTool } from "@mariozechner/pi-agent-core";
+import { capturePhotoSchema } from "./shared.js";
+export declare function createCapturePhotoTool(cwd: string): AgentTool<typeof capturePhotoSchema>;

package/dist/tools/capture-photo.js

@@ -0,0 +1,91 @@
+import { readFile, writeFile, mkdir, stat } from "fs/promises";
+import { join } from "path";
+import { execSync } from "child_process";
+import { capturePhotoSchema } from "./shared.js";
+const PHOTOS_DIR = "memory/photos";
+const INDEX_FILE = "memory/photos/INDEX.md";
+const LATEST_FRAME_FILE = "memory/.latest-frame.jpg";
+function slugify(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-|-$/g, "")
+        .slice(0, 40);
+}
+export function createCapturePhotoTool(cwd) {
+    return {
+        name: "capture_photo",
+        label: "capture_photo",
+        description: "Capture a photo from the webcam during a memorable moment. Reads the latest camera frame, saves it as a named photo in memory/photos/, updates the index, and commits to git.",
+        parameters: capturePhotoSchema,
+        execute: async (_toolCallId, { reason }, signal) => {
+            if (signal?.aborted)
+                throw new Error("Operation aborted");
+            const framePath = join(cwd, LATEST_FRAME_FILE);
+            // Check if frame file exists and isn't stale
+            let frameStat;
+            try {
+                frameStat = await stat(framePath);
+            }
+            catch {
+                return {
+                    content: [{ type: "text", text: "No camera frame available. The webcam may not be active." }],
+                    details: undefined,
+                };
+            }
+            const ageMs = Date.now() - frameStat.mtimeMs;
+            if (ageMs > 5000) {
+                return {
+                    content: [{ type: "text", text: "No recent camera frame (camera may be off). Last frame is too stale to capture." }],
+                    details: undefined,
+                };
+            }
+            // Read the frame
+            const frameData = await readFile(framePath);
+            // Build filename
+            const now = new Date();
+            const pad = (n) => String(n).padStart(2, "0");
+            const datePart = `${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}`;
+            const timePart = `${pad(now.getHours())}${pad(now.getMinutes())}${pad(now.getSeconds())}`;
+            const slug = slugify(reason);
+            const filename = `${datePart}_${timePart}_${slug}.jpg`;
+            const photoRelPath = `${PHOTOS_DIR}/${filename}`;
+            const photoAbsPath = join(cwd, photoRelPath);
+            // Ensure photos directory exists
+            await mkdir(join(cwd, PHOTOS_DIR), { recursive: true });
+            // Write photo
+            await writeFile(photoAbsPath, frameData);
+            // Update INDEX.md
+            const indexPath = join(cwd, INDEX_FILE);
+            let indexContent = "";
+            try {
+                indexContent = await readFile(indexPath, "utf-8");
+            }
+            catch {
+                indexContent = "# Memorable Moments\n\nPhotos captured during happy and memorable moments.\n\n";
+            }
+            const entry = `- **${datePart} ${pad(now.getHours())}:${pad(now.getMinutes())}:${pad(now.getSeconds())}** — ${reason} → [\`${filename}\`](${filename})\n`;
+            indexContent += entry;
+            await writeFile(indexPath, indexContent, "utf-8");
+            // Git add + commit
+            const commitMsg = `Capture moment: ${reason}`;
+            try {
+                execSync(`git add "${photoRelPath}" "${INDEX_FILE}" && git commit -m "${commitMsg.replace(/"/g, '\\"')}"`, {
+                    cwd,
+                    stdio: "pipe",
+                });
+            }
+            catch (err) {
+                const stderr = err.stderr?.toString() || "";
+                return {
+                    content: [{ type: "text", text: `Photo saved to ${photoRelPath} but git commit failed: ${stderr.trim() || "unknown error"}` }],
+                    details: undefined,
+                };
+            }
+            return {
+                content: [{ type: "text", text: `Memorable moment captured! Photo saved to ${photoRelPath} and committed: "${commitMsg}"` }],
+                details: undefined,
+            };
+        },
+    };
+}

package/dist/tools/index.d.ts

@@ -4,9 +4,10 @@ export interface BuiltinToolsConfig {
     dir: string;
     timeout?: number;
     sandbox?: SandboxContext;
+    gitagentDir?: string;
 }
 /**
- * Create the four built-in tools (cli, read, write, memory).
+ * Create the built-in tools (cli, read, write, memory, task_tracker, skill_learner).
  * If a SandboxContext is provided, returns sandbox-backed tools;
  * otherwise returns the standard local tools.
  */

package/dist/tools/index.js

@@ -2,12 +2,15 @@ import { createCliTool } from "./cli.js";
 import { createReadTool } from "./read.js";
 import { createWriteTool } from "./write.js";
 import { createMemoryTool } from "./memory.js";
+import { createTaskTrackerTool } from "./task-tracker.js";
+import { createSkillLearnerTool } from "./skill-learner.js";
+import { createCapturePhotoTool } from "./capture-photo.js";
 import { createSandboxCliTool } from "./sandbox-cli.js";
 import { createSandboxReadTool } from "./sandbox-read.js";
 import { createSandboxWriteTool } from "./sandbox-write.js";
 import { createSandboxMemoryTool } from "./sandbox-memory.js";
 /**
- * Create the four built-in tools (cli, read, write, memory).
+ * Create the built-in tools (cli, read, write, memory, task_tracker, skill_learner).
  * If a SandboxContext is provided, returns sandbox-backed tools;
  * otherwise returns the standard local tools.
  */
@@ -20,10 +23,17 @@ export function createBuiltinTools(config) {
             createSandboxMemoryTool(config.sandbox),
         ];
     }
-    return [
+    const tools = [
         createCliTool(config.dir, config.timeout),
         createReadTool(config.dir),
         createWriteTool(config.dir),
         createMemoryTool(config.dir),
+        createCapturePhotoTool(config.dir),
     ];
+    // Add learning tools if gitagentDir is available
+    if (config.gitagentDir) {
+        tools.push(createTaskTrackerTool(config.dir, config.gitagentDir));
+        tools.push(createSkillLearnerTool(config.dir, config.gitagentDir));
+    }
+    return tools;
 }

package/dist/tools/read.js

@@ -1,7 +1,11 @@
 import { readFile } from "fs/promises";
 import { resolve } from "path";
+import { homedir } from "os";
 import { readSchema, MAX_LINES, paginateLines } from "./shared.js";
 function resolvePath(path, cwd) {
+    if (path.startsWith("~/") || path === "~") {
+        path = homedir() + path.slice(1);
+    }
     return path.startsWith("/") ? path : resolve(cwd, path);
 }
 function isBinary(buffer) {

package/dist/tools/shared.d.ts

@@ -22,6 +22,26 @@ export declare const memorySchema: import("@sinclair/typebox").TObject<{
     content: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
     message: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
 }>;
+export declare const taskTrackerSchema: import("@sinclair/typebox").TObject<{
+    action: import("@sinclair/typebox").TUnsafe<string>;
+    objective: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    task_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    step: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    outcome: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TUnsafe<string>>;
+    failure_reason: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    skill_used: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+}>;
+export declare const capturePhotoSchema: import("@sinclair/typebox").TObject<{
+    reason: import("@sinclair/typebox").TString;
+}>;
+export declare const skillLearnerSchema: import("@sinclair/typebox").TObject<{
+    action: import("@sinclair/typebox").TUnsafe<string>;
+    task_id: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    skill_name: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    skill_description: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    instructions: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    override_heuristic: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>;
 /** Truncate output to MAX_OUTPUT, keeping the tail. */
 export declare function truncateOutput(text: string): string;
 /**