terry-core 1.0.0 → 1.0.3

package/dist/config.d.ts

@@ -2,6 +2,7 @@ import { type WorkspaceSettings } from "./types.js";
 export declare function terryHomeDir(): string;
 export declare function workspacesFile(): string;
 export declare function auditLogFile(): string;
+export declare function telemetryLogFile(): string;
 export declare function usageDir(): string;
 export declare function cloudSyncConfigFile(): string;
 export declare function memoryFile(): string;

package/dist/config.js

@@ -7,11 +7,13 @@ const DEFAULT_TOOLS = {
     listDirectory: "enabled",
     readFile: "enabled",
     writeFile: "enabled",
+    moveFile: "enabled",
     searchInFiles: "enabled",
     webSearch: "enabled",
     gitStatus: "enabled",
     gitDiff: "enabled",
     runCommand: "enabled",
+    imageGenerate: "ask",
     memorySet: "enabled",
     memoryGet: "enabled",
     openCalendarEvent: "ask",
@@ -22,6 +24,22 @@ const DEFAULT_TOOLS = {
     openEmail: "ask",
     openMapsDirections: "ask"
 };
+function normalizeExecutionMode(value) {
+    const normalized = String(value ?? "").trim().toLowerCase();
+    if (normalized === "autonomous")
+        return "full";
+    if (normalized === "plan" || normalized === "safe" || normalized === "full") {
+        return normalized;
+    }
+    return DEFAULT_EXECUTION_MODE;
+}
+function normalizeWorkspaceKey(workspacePath) {
+    const resolved = path.resolve(workspacePath);
+    return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function canonicalWorkspacePath(workspacePath) {
+    return path.resolve(workspacePath);
+}
 export function terryHomeDir() {
     return path.join(os.homedir(), ".terry");
 }
@@ -31,6 +49,9 @@ export function workspacesFile() {
 export function auditLogFile() {
     return path.join(terryHomeDir(), "audit.log.jsonl");
 }
+export function telemetryLogFile() {
+    return path.join(terryHomeDir(), "telemetry.log.jsonl");
+}
 export function usageDir() {
     return path.join(terryHomeDir(), "usage");
 }
@@ -60,10 +81,23 @@ export async function saveWorkspaceMap(map) {
 }
 export async function getWorkspaceSettings(workspacePath) {
     const map = await loadWorkspaceMap();
-    const key = path.resolve(workspacePath);
+    const key = normalizeWorkspaceKey(workspacePath);
+    const canonicalPath = canonicalWorkspacePath(workspacePath);
+    const legacyKey = Object.keys(map).find((entry) => normalizeWorkspaceKey(entry) === key);
+    if (legacyKey && legacyKey !== key) {
+        const legacyValue = map[legacyKey];
+        if (legacyValue) {
+            map[key] = {
+                ...legacyValue,
+                workspacePath: canonicalPath
+            };
+            delete map[legacyKey];
+            await saveWorkspaceMap(map);
+        }
+    }
     if (!map[key]) {
         map[key] = {
-            workspacePath: key,
+            workspacePath: canonicalPath,
             dryRun: false,
             mode: DEFAULT_MODE,
             executionMode: DEFAULT_EXECUTION_MODE,
@@ -75,12 +109,20 @@ export async function getWorkspaceSettings(workspacePath) {
         map[key] = {
             ...map[key],
             mode: DEFAULT_MODE,
-            executionMode: map[key].executionMode ?? DEFAULT_EXECUTION_MODE,
+            executionMode: normalizeExecutionMode(map[key].executionMode),
             tools: { ...DEFAULT_TOOLS, ...map[key].tools }
         };
         await saveWorkspaceMap(map);
     }
     else {
+        const normalizedExecution = normalizeExecutionMode(map[key].executionMode);
+        if (normalizedExecution !== map[key].executionMode) {
+            map[key] = {
+                ...map[key],
+                executionMode: normalizedExecution
+            };
+            await saveWorkspaceMap(map);
+        }
         const levels = Object.values(map[key].tools ?? {});
         const allDisabled = levels.length > 0 && levels.every((level) => level === "disabled");
         const legacyPattern = map[key].tools?.listDirectory === "disabled" &&
@@ -110,17 +152,31 @@ export async function getWorkspaceSettings(workspacePath) {
 }
 export async function setWorkspaceSettings(workspacePath, patch) {
     const map = await loadWorkspaceMap();
-    const key = path.resolve(workspacePath);
+    const key = normalizeWorkspaceKey(workspacePath);
+    const canonicalPath = canonicalWorkspacePath(workspacePath);
+    const legacyKey = Object.keys(map).find((entry) => normalizeWorkspaceKey(entry) === key);
+    if (legacyKey && legacyKey !== key) {
+        const legacyValue = map[legacyKey];
+        if (legacyValue) {
+            map[key] = {
+                ...legacyValue,
+                workspacePath: canonicalPath
+            };
+            delete map[legacyKey];
+        }
+    }
     const current = map[key] ?? {
-        workspacePath: key,
+        workspacePath: canonicalPath,
         dryRun: false,
         mode: DEFAULT_MODE,
         executionMode: DEFAULT_EXECUTION_MODE,
         tools: { ...DEFAULT_TOOLS }
     };
+    const nextExecutionMode = normalizeExecutionMode((patch.executionMode ?? current.executionMode));
     map[key] = {
         ...current,
         ...patch,
+        executionMode: nextExecutionMode,
         tools: { ...current.tools, ...(patch.tools ?? {}) }
     };
     await saveWorkspaceMap(map);

package/dist/index.d.ts

@@ -15,3 +15,5 @@ export * from "./status.js";
 export * from "./templates.js";
 export * from "./health.js";
 export * from "./usage.js";
+export * from "./status-events.js";
+export * from "./telemetry.js";

package/dist/index.js

@@ -15,3 +15,5 @@ export * from "./status.js";
 export * from "./templates.js";
 export * from "./health.js";
 export * from "./usage.js";
+export * from "./status-events.js";
+export * from "./telemetry.js";

package/dist/orchestrator.d.ts

@@ -1,2 +1,3 @@
-import type { DecideNextAction } from "./types.js";
+import type { DecideNextAction, ToolName } from "./types.js";
+export declare function inferArgsForTool(tool: ToolName, content: string): unknown;
 export declare const rulesOrchestrator: DecideNextAction;

package/dist/orchestrator.js

@@ -1,6 +1,22 @@
-const KNOWN_COMMANDS = ["git", "npm", "pnpm", "yarn", "node", "npx"];
+const KNOWN_COMMANDS = [
+    "git",
+    "npm",
+    "pnpm",
+    "yarn",
+    "node",
+    "npx",
+    "powershell",
+    "pwsh",
+    "cmd",
+    "bash",
+    "sh",
+    "python",
+    "python3"
+];
 const TOOL_HINTS = [
-    { tool: "webSearch", match: /\b(web search|search web|lookup online|latest on|news on|current events?)\b/i },
+    { tool: "webSearch", match: /\b(web search|search web|lookup online|latest(?:\s+on)?|news(?:\s+on)?|current events?)\b/i },
+    { tool: "imageGenerate", match: /\b(generate|create|make|design)\b.*\b(image|logo|icon|picture|art|illustration)\b|\b(dall[- ]?e|image generation)\b/i },
+    { tool: "moveFile", match: /\b(move|rename)\b.*\b(file|folder|directory)\b|\bmove\s+.+\s+to\s+.+\b/i },
     { tool: "memorySet", match: /\bremember(?:\s+that)?\b/i },
     { tool: "memoryGet", match: /\b(what do you remember|what did i tell you|recall|remember my|what is my)\b/i },
     { tool: "openCalendarEvent", match: /\b(schedule|calendar|meeting|event)\b/i },
@@ -10,7 +26,7 @@ const TOOL_HINTS = [
     { tool: "openSlackCompose", match: /\bslack\b.*\b(message|send|compose)\b/i },
     { tool: "openEmail", match: /\b(draft an email|send an email|mailto|email)\b/i },
     { tool: "openMapsDirections", match: /\b(directions?|navigate|maps?)\b/i },
-    { tool: "runCommand", match: /\b(run|execute)\b|\b(git|npm|pnpm|yarn|node|npx)\b/i },
+    { tool: "runCommand", match: /\b(run|execute)\b|\b(git|npm|pnpm|yarn|node|npx|powershell|pwsh|cmd|bash|python|python3)\b/i },
     { tool: "writeFile", match: /\b(write|create|update|edit|save)\b.*\b(file|readme|json|md|ts|js)\b/i },
     { tool: "readFile", match: /\b(read|open|show)\b.*\b(file|readme|json|md|ts|js)\b/i },
     { tool: "searchInFiles", match: /\b(search|find|grep|look for)\b/i },
@@ -18,6 +34,27 @@ const TOOL_HINTS = [
     { tool: "gitDiff", match: /\bgit diff|show diff|changes\b/i },
     { tool: "listDirectory", match: /\b(list|ls|folders?|directories?)\b/i }
 ];
+const TOOL_PRECEDENCE = [
+    "imageGenerate",
+    "webSearch",
+    "openCalendarEvent",
+    "openGitHubIssue",
+    "openNotionPage",
+    "openLinearIssue",
+    "openSlackCompose",
+    "openEmail",
+    "openMapsDirections",
+    "memorySet",
+    "memoryGet",
+    "runCommand",
+    "writeFile",
+    "moveFile",
+    "readFile",
+    "searchInFiles",
+    "gitStatus",
+    "gitDiff",
+    "listDirectory"
+];
 function stripWrappers(value) {
     return value.trim().replace(/^["'`]|["'`]$/g, "");
 }
@@ -59,7 +96,13 @@ function extractFirstPath(content) {
     const quoted = content.match(/["'`]([^"'`]+)["'`]/);
     if (quoted?.[1])
         return quoted[1].trim();
-    const direct = content.match(/\b([./\\]?[a-zA-Z0-9_\-/\\.]+\.[a-zA-Z0-9_]+)\b/);
+    const windows = content.match(/\b([a-zA-Z]:\\[^\s"'`]+(?:\\[^\s"'`]+)*\.[a-zA-Z0-9_]+)\b/);
+    if (windows?.[1])
+        return windows[1].trim();
+    const unixAbs = content.match(/(?:^|[\s"'`])(\/[^\s"'`]+(?:\/[^\s"'`]+)*\.[a-zA-Z0-9_]+)/);
+    if (unixAbs?.[1])
+        return unixAbs[1].trim();
+    const direct = content.match(/\b([./\\]?[a-zA-Z0-9_./\\-]+\.[a-zA-Z0-9_]+)\b/);
     if (direct?.[1])
         return direct[1].trim();
     return null;
@@ -121,7 +164,7 @@ function parseRunCommand(content) {
         content.match(/\b(?:run|execute)(?:\s+the)?(?:\s+command)?\s+(.+)$/i)?.[1] ??
         content.match(new RegExp(`^\\s*(${KNOWN_COMMANDS.join("|")})\\b(.+)?$`, "i"))?.[0] ??
         "";
-    const normalized = candidate.trim().replace(/[.;,\s]+$/g, "");
+    const normalized = candidate.trim().replace(/^[>]+/, "").replace(/[.;,\s]+$/g, "");
     if (!normalized)
         return null;
     const tokens = tokenizeCommand(normalized);
@@ -151,6 +194,25 @@ function parseWriteFileArgs(content) {
         content: contentMatch.trim()
     };
 }
+function parseMoveFileArgs(content) {
+    const quoted = [...content.matchAll(/["'`]([^"'`]+)["'`]/g)]
+        .map((match) => match[1]?.trim())
+        .filter((value) => Boolean(value));
+    if (quoted.length >= 2) {
+        return {
+            fromPathRelativeToWorkspace: quoted[0],
+            toPathRelativeToWorkspace: quoted[1]
+        };
+    }
+    const moveTo = content.match(/\b(?:move|rename)\s+(.+?)\s+\bto\b\s+(.+)$/i);
+    if (moveTo?.[1] && moveTo?.[2]) {
+        return {
+            fromPathRelativeToWorkspace: stripWrappers(moveTo[1].trim()),
+            toPathRelativeToWorkspace: stripWrappers(moveTo[2].trim())
+        };
+    }
+    return null;
+}
 function parseSearchArgs(content) {
     const quoted = content.match(/["'`]([^"'`]+)["'`]/)?.[1];
     const phrase = quoted ??
@@ -187,6 +249,29 @@ function parseMemoryGetArgs(content) {
         content.replace(/\?+$/, "");
     return { key: parsed.trim() || "note" };
 }
+function parseImageGenerateArgs(content) {
+    const prompt = extractQuoted(content) ??
+        content
+            .replace(/\b(generate|create|make|design)\b/gi, "")
+            .replace(/\b(an?|the)\b/gi, "")
+            .replace(/\b(image|logo|icon|picture|art|illustration)\b/gi, "")
+            .replace(/\b(for me|please)\b/gi, "")
+            .replace(/\s+/g, " ")
+            .trim();
+    const sizeMatch = content.match(/\b(1024x1024|1024x1536|1536x1024)\b/i)?.[1]?.toLowerCase();
+    const quality = /\b(hd|high quality)\b/i.test(content) ? "hd" : "standard";
+    const style = /\bnatural\b/i.test(content) ? "natural" : "vivid";
+    const filePath = content.match(/\b(?:to|into|save(?:d)?(?:\s+to)?)\s+["'`]([^"'`]+\.(?:png|jpg|jpeg))["'`]/i)?.[1] ??
+        content.match(/\b(?:to|into|save(?:d)?(?:\s+to)?)\s+([^\s]+\.(?:png|jpg|jpeg))\b/i)?.[1] ??
+        undefined;
+    return {
+        prompt: prompt || "A clean terminal-themed image concept",
+        size: sizeMatch ?? "1024x1024",
+        quality,
+        style,
+        pathRelativeToWorkspace: filePath
+    };
+}
 function parseCalendarArgs(content) {
     const quoted = extractQuoted(content);
     const title = quoted ??
@@ -254,18 +339,125 @@ function parseDirectionsArgs(content) {
     const provider = /\bapple maps?\b/i.test(content) ? "apple" : "google";
     return { destination, provider };
 }
-function inferTool(content) {
+function isDeepLinkTool(tool) {
+    return (tool === "openCalendarEvent" ||
+        tool === "openGitHubIssue" ||
+        tool === "openNotionPage" ||
+        tool === "openLinearIssue" ||
+        tool === "openSlackCompose" ||
+        tool === "openEmail" ||
+        tool === "openMapsDirections");
+}
+function precedenceIndex(tool) {
+    const idx = TOOL_PRECEDENCE.indexOf(tool);
+    return idx === -1 ? TOOL_PRECEDENCE.length : idx;
+}
+function scoreToolMatch(tool, content, baseScore) {
+    let score = baseScore;
+    if (tool === "runCommand") {
+        score += parseRunCommand(content) ? 3 : -0.7;
+        if (/\b(git status|git diff|show diff|repo status|what changed)\b/i.test(content)) {
+            score -= 2;
+        }
+    }
+    if (tool === "gitStatus" && /\bgit status\b|\brepo status\b|\bwhat changed\b/i.test(content)) {
+        score += 3;
+    }
+    if (tool === "gitDiff" && /\bgit diff\b|\bshow diff\b|\bchanges\b/i.test(content)) {
+        score += 2.5;
+    }
+    if (tool === "imageGenerate" && /\b(image|logo|icon|picture|photo|art|illustration|graphic)\b/i.test(content)) {
+        score += 1.5;
+    }
+    if (tool === "webSearch" && /\b(latest|today|news|current|online|web)\b/i.test(content)) {
+        score += 1.4;
+    }
+    if ((tool === "readFile" || tool === "writeFile" || tool === "moveFile") && extractFirstPath(content)) {
+        score += 1.1;
+    }
+    if (tool === "listDirectory" && /\b(list|ls|folders?|directories?)\b/i.test(content)) {
+        score += 1.2;
+    }
+    if (tool === "searchInFiles" && /\b(todo|fixme|pattern|match|grep)\b/i.test(content)) {
+        score += 0.8;
+    }
+    if (tool === "openCalendarEvent" && /\b(tomorrow|today|at\s+\d|meeting|event)\b/i.test(content)) {
+        score += 1;
+    }
+    if (tool === "openNotionPage" && /\bnotion\b.*\b(page|note)\b/i.test(content)) {
+        score += 2;
+    }
+    if (tool === "openLinearIssue" && /\b(linear|jira)\b.*\b(issue|ticket)\b/i.test(content)) {
+        score += 2;
+    }
+    if (tool === "openSlackCompose" && /\bslack\b.*\b(message|send|compose)\b/i.test(content)) {
+        score += 2;
+    }
+    if (tool === "openMapsDirections" && /\b(directions?|navigate|maps?)\b/i.test(content)) {
+        score += 1.8;
+    }
+    if (tool === "openEmail" && /\b(draft an email|send an email|mailto|email)\b/i.test(content)) {
+        score += 1.4;
+    }
+    if (tool === "memorySet" && /\bremember(?:\s+that)?\b/i.test(content) && /\b(is|=|as|:)\b/i.test(content)) {
+        score += 1.3;
+    }
+    if (tool === "memoryGet" && /\b(what do you remember|what did i tell you|recall|remember my|what is my)\b/i.test(content)) {
+        score += 1.3;
+    }
+    if (tool === "openGitHubIssue" && /\b(github|label|repo|issue)\b/i.test(content)) {
+        score += 1;
+    }
+    if (tool === "openEmail" && /\b(to\s+[a-z0-9._%+-]+@[a-z0-9.-]+\.[a-z]{2,}|subject)\b/i.test(content)) {
+        score += 1;
+    }
+    return score;
+}
+function inferTool(content, availableTools) {
+    const candidates = [];
     for (const hint of TOOL_HINTS) {
-        if (hint.match.test(content))
-            return hint.tool;
+        if (!availableTools.includes(hint.tool))
+            continue;
+        if (!hint.match.test(content))
+            continue;
+        const candidate = {
+            tool: hint.tool,
+            score: scoreToolMatch(hint.tool, content, 1)
+        };
+        candidates.push(candidate);
     }
-    return null;
+    candidates.sort((a, b) => {
+        if (b.score !== a.score)
+            return b.score - a.score;
+        return precedenceIndex(a.tool) - precedenceIndex(b.tool);
+    });
+    if (candidates.length === 0) {
+        return { tool: null, confidence: "none", alternatives: [] };
+    }
+    const top = candidates[0];
+    const second = candidates[1];
+    const gap = second ? top.score - second.score : top.score;
+    let confidence = "medium";
+    if (top.score >= 2.4 && gap >= 0.7)
+        confidence = "high";
+    else if (top.score < 1.2 || gap < 0.2)
+        confidence = "low";
+    if (second && isDeepLinkTool(top.tool) && isDeepLinkTool(second.tool) && top.tool !== second.tool) {
+        confidence = "low";
+    }
+    return {
+        tool: top.tool,
+        confidence,
+        alternatives: candidates.slice(1, 3).map((candidate) => candidate.tool)
+    };
 }
-function inferArgs(tool, content) {
+export function inferArgsForTool(tool, content) {
     if (tool === "searchInFiles")
         return parseSearchArgs(content);
     if (tool === "webSearch")
         return parseWebSearchArgs(content);
+    if (tool === "imageGenerate")
+        return parseImageGenerateArgs(content);
     if (tool === "runCommand")
         return parseRunCommand(content);
     if (tool === "listDirectory")
@@ -280,6 +472,8 @@ function inferArgs(tool, content) {
         return parseReadFileArgs(content);
     if (tool === "writeFile")
         return parseWriteFileArgs(content);
+    if (tool === "moveFile")
+        return parseMoveFileArgs(content);
     if (tool === "memorySet")
         return parseMemorySetArgs(content);
     if (tool === "memoryGet")
@@ -300,24 +494,43 @@ function inferArgs(tool, content) {
         return parseDirectionsArgs(content);
     return {};
 }
-export const rulesOrchestrator = (messages) => {
+export const rulesOrchestrator = (messages, tools) => {
     const lastUser = [...messages].reverse().find((m) => m.role === "user");
     if (!lastUser)
         return { kind: "summarize", summary: "No task provided." };
-    const tool = inferTool(lastUser.content);
+    const inference = inferTool(lastUser.content, tools);
+    const tool = inference.tool;
     if (!tool) {
         return {
             kind: "summarize",
-            summary: "I can help with workspace files, search, git, memory, and assistant actions like calendar/email/deep-links."
+            summary: "I can help with workspace files (read/write/move), search, git, memory, deep-links (calendar/email/issues), and image generation."
         };
     }
-    const args = inferArgs(tool, lastUser.content);
+    const args = inferArgsForTool(tool, lastUser.content);
     if (tool === "runCommand" && !args) {
         return {
             kind: "summarize",
             summary: "I can run approved workspace commands. Please provide an explicit command, for example: run `npm test`."
         };
     }
+    if (tool === "moveFile" && !args) {
+        return {
+            kind: "summarize",
+            summary: "Please provide both source and destination paths. Example: move \"docs/old.md\" to \"docs/new.md\"."
+        };
+    }
+    if (inference.confidence === "low") {
+        if (inference.alternatives.length > 0) {
+            return {
+                kind: "summarize",
+                summary: `I can do this, but I need one clarification. Did you want ${tool}, or ${inference.alternatives.join(" / ")}?`
+            };
+        }
+        return {
+            kind: "summarize",
+            summary: `I can handle this with ${tool}, but I need one detail to avoid the wrong action. Please provide exact file path or command.`
+        };
+    }
     return {
         kind: "ask_permission",
         tool,

package/dist/permissions.js

@@ -2,6 +2,8 @@ export function getToolPermission(settings, tool) {
     return settings.tools[tool] ?? "disabled";
 }
 export function shouldAskEveryTime(settings, tool) {
+    if (settings.executionMode === "full")
+        return false;
     if (tool === "runCommand")
         return true;
     if (tool === "writeFile")
@@ -18,7 +20,7 @@ export function isToolEnabled(settings, tool) {
 export function toolRiskLevel(tool) {
     if (tool === "runCommand")
         return "high";
-    if (tool === "writeFile")
+    if (tool === "writeFile" || tool === "moveFile" || tool === "imageGenerate")
         return "medium";
     if (tool === "openCalendarEvent" ||
         tool === "openGitHubIssue" ||

package/dist/policy.js

@@ -7,7 +7,21 @@ const READ_ONLY_TOOLS = [
     "gitDiff",
     "memoryGet"
 ];
-const COMMAND_ALLOWLIST = new Set(["git", "npm", "pnpm", "yarn", "node", "npx"]);
+const COMMAND_ALLOWLIST = new Set([
+    "git",
+    "npm",
+    "pnpm",
+    "yarn",
+    "node",
+    "npx",
+    "powershell",
+    "pwsh",
+    "cmd",
+    "bash",
+    "sh",
+    "python",
+    "python3"
+]);
 export function isReadOnlyTool(tool) {
     return READ_ONLY_TOOLS.includes(tool);
 }
@@ -27,7 +41,10 @@ export function shouldExecuteInMode(settings, tool, args) {
             return { execute: true, ask: false, reason: "Safe mode auto-executes read-only tools." };
         return { execute: false, ask: true, reason: "Safe mode requires approval for writes and commands." };
     }
-    if (tool === "runCommand") {
+    if (mode === "full") {
+        return { execute: true, ask: false, reason: "Full access executes tools directly." };
+    }
+    if (mode === "autonomous" && tool === "runCommand") {
         const cmd = args?.cmd ?? "";
         if (!isCommandAllowlisted(cmd)) {
             return {
@@ -37,5 +54,8 @@ export function shouldExecuteInMode(settings, tool, args) {
             };
         }
     }
-    return { execute: true, ask: false, reason: "Autonomous mode executes approved plan directly." };
+    if (mode === "autonomous") {
+        return { execute: true, ask: false, reason: "Autonomous mode executes approved plan directly." };
+    }
+    return { execute: false, ask: true, reason: "Unknown execution mode; approval required." };
 }

package/dist/status-events.d.ts

@@ -0,0 +1,9 @@
+import type { ToolName } from "./types.js";
+export type ToolStage = "planning" | "requesting_model" | "rendering" | "receiving_payload" | "saving_file" | "completed" | "failed";
+export type StatusEvent = "planning" | "planning:cloud" | `proposed:${ToolName}` | `approval:${ToolName}` | `executing:${ToolName}` | `blocked:${ToolName}` | `tool:${ToolName}:${string}` | "complete" | "failed" | "cancelled";
+export declare function statusProposed(tool: ToolName): StatusEvent;
+export declare function statusApproval(tool: ToolName): StatusEvent;
+export declare function statusExecuting(tool: ToolName): StatusEvent;
+export declare function statusBlocked(tool: ToolName): StatusEvent;
+export declare function statusToolStage(tool: ToolName, stage: ToolStage | string): StatusEvent;
+export declare function parseStatusEvent(raw: string): StatusEvent;

package/dist/status-events.js

@@ -0,0 +1,27 @@
+export function statusProposed(tool) {
+    return `proposed:${tool}`;
+}
+export function statusApproval(tool) {
+    return `approval:${tool}`;
+}
+export function statusExecuting(tool) {
+    return `executing:${tool}`;
+}
+export function statusBlocked(tool) {
+    return `blocked:${tool}`;
+}
+export function statusToolStage(tool, stage) {
+    return `tool:${tool}:${stage}`;
+}
+export function parseStatusEvent(raw) {
+    if (raw === "planning" || raw === "planning:cloud" || raw === "complete" || raw === "failed" || raw === "cancelled") {
+        return raw;
+    }
+    if (/^(proposed|approval|executing|blocked):[a-zA-Z]+$/.test(raw)) {
+        return raw;
+    }
+    if (/^tool:[a-zA-Z]+:[a-zA-Z0-9_:-]+$/.test(raw)) {
+        return raw;
+    }
+    return "failed";
+}

package/dist/telemetry.d.ts

@@ -0,0 +1,9 @@
+export type TelemetryEvent = {
+    timestamp: string;
+    event: string;
+    workspacePath?: string;
+    sessionId?: string;
+    status?: string;
+    metadata?: Record<string, unknown>;
+};
+export declare function appendTelemetryEvent(event: TelemetryEvent): Promise<void>;

package/dist/telemetry.js

@@ -0,0 +1,12 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { telemetryLogFile } from "./config.js";
+export async function appendTelemetryEvent(event) {
+    try {
+        await fs.mkdir(path.dirname(telemetryLogFile()), { recursive: true });
+        await fs.appendFile(telemetryLogFile(), `${JSON.stringify(event)}\n`, "utf8");
+    }
+    catch {
+        // Telemetry failures should never block primary flows.
+    }
+}

package/dist/tools.d.ts

@@ -2,6 +2,7 @@ import type { ToolArgsMap, ToolName, ToolResult, WorkspaceSettings } from "./typ
 type ToolContext = {
     workspacePath: string;
     settings: WorkspaceSettings;
+    onStatus?: (status: string) => void;
     cloud?: {
         webSearch?: (query: string, maxResults?: number) => Promise<{
             query: string;
@@ -12,6 +13,12 @@ type ToolContext = {
                 snippet: string;
             }>;
         }>;
+        imageGenerate?: (args: ToolArgsMap["imageGenerate"], onProgress?: (stage: "requesting" | "rendering" | "received") => void) => Promise<{
+            model: string;
+            mimeType: string;
+            base64: string;
+            revisedPrompt?: string;
+        }>;
     };
 };
 export declare function executeTool<T extends ToolName>(context: ToolContext, tool: T, args: ToolArgsMap[T]): Promise<ToolResult>;

package/dist/tools.js

@@ -7,6 +7,7 @@ import { resolveInWorkspace } from "./sandbox.js";
 import { appendAudit } from "./audit.js";
 import { applyPatchProposal, createPatchProposal } from "./patches.js";
 import { memoryFile } from "./config.js";
+import { statusToolStage } from "./status-events.js";
 const execFileAsync = promisify(execFile);
 function dryRunResult(tool, files = []) {
     return { ok: true, output: `[dry-run] ${tool} skipped execution.`, files };
@@ -98,6 +99,61 @@ function buildMapsUrl(args) {
     }
     return `https://www.google.com/maps/dir/?api=1&destination=${encodeURIComponent(args.destination)}`;
 }
+function sanitizeFileStem(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 48);
+}
+function imageExtFromMime(mimeType) {
+    const lowered = mimeType.toLowerCase();
+    if (lowered.includes("jpeg") || lowered.includes("jpg"))
+        return "jpg";
+    if (lowered.includes("webp"))
+        return "webp";
+    return "png";
+}
+function imageFailureMessage(kind, detail) {
+    const cleanDetail = (detail ?? "").trim();
+    const suffix = cleanDetail ? ` Detail: ${cleanDetail}` : "";
+    if (kind === "invalid_prompt") {
+        return ("Image generation failed [invalid_prompt]. Provide a non-empty prompt after /image or \"generate image\"." +
+            suffix);
+    }
+    if (kind === "config_missing") {
+        return ("Image generation failed [config_missing]. Configure Supabase secrets OPENAI_API_KEY and OPENAI_IMAGE_MODEL, then redeploy image-generate." +
+            suffix);
+    }
+    if (kind === "auth_session") {
+        return ("Image generation failed [auth_session]. Run \"terry auth login\", then verify \"terry cloud status\" shows a valid session." +
+            suffix);
+    }
+    if (kind === "file_save") {
+        return ("Image generation failed [file_save]. Terry generated the image but could not save it. Check file path permissions and disk availability." +
+            suffix);
+    }
+    return ("Image generation failed [upstream]. The image API request failed. Retry once, then inspect Supabase function logs for image-generate." +
+        suffix);
+}
+function classifyImageCloudFailure(raw) {
+    const lowered = raw.toLowerCase();
+    if (lowered.includes("[cloud_misconfigured]") ||
+        lowered.includes("cloud is not configured") ||
+        lowered.includes("server configuration is incomplete") ||
+        lowered.includes("openai_api_key")) {
+        return "config_missing";
+    }
+    if (lowered.includes("[auth_failed]") ||
+        lowered.includes("[auth_required]") ||
+        lowered.includes("not logged in") ||
+        lowered.includes("session expired") ||
+        lowered.includes("authentication failed") ||
+        lowered.includes("unauthorized")) {
+        return "auth_session";
+    }
+    return "upstream";
+}
 async function openExternalUrl(url) {
     if (process.platform === "win32") {
         const escaped = url.replace(/'/g, "''");
@@ -168,7 +224,7 @@ export async function executeTool(context, tool, args) {
                 const full = resolveInWorkspace(context.workspacePath, parsed.pathRelativeToWorkspace);
                 const proposal = await createPatchProposal(context.workspacePath, parsed.pathRelativeToWorkspace, parsed.content, {
                     persist: !context.settings.dryRun,
-                    preApproveAll: context.settings.executionMode === "autonomous"
+                    preApproveAll: context.settings.executionMode === "full" || context.settings.executionMode === "autonomous"
                 });
                 if (context.settings.dryRun) {
                     return {
@@ -193,6 +249,21 @@ export async function executeTool(context, tool, args) {
                     patchProposalId: proposal.id
                 };
             });
+        case "moveFile":
+            return withAudit(context, tool, args, [], async () => {
+                const parsed = args;
+                const fromPath = resolveInWorkspace(context.workspacePath, parsed.fromPathRelativeToWorkspace);
+                const toPath = resolveInWorkspace(context.workspacePath, parsed.toPathRelativeToWorkspace);
+                if (context.settings.dryRun)
+                    return dryRunResult(tool, [fromPath, toPath]);
+                await fs.mkdir(path.dirname(toPath), { recursive: true });
+                await fs.rename(fromPath, toPath);
+                return {
+                    ok: true,
+                    output: `Moved ${parsed.fromPathRelativeToWorkspace} -> ${parsed.toPathRelativeToWorkspace}`,
+                    files: [fromPath, toPath]
+                };
+            });
         case "searchInFiles":
             return withAudit(context, tool, args, [], async () => {
                 const parsed = args;
@@ -265,6 +336,92 @@ export async function executeTool(context, tool, args) {
                 const { stdout, stderr } = await execFileAsync(parsed.cmd, parsed.args ?? [], { cwd });
                 return { ok: true, output: `${stdout}${stderr}`.trim() };
             });
+        case "imageGenerate":
+            return withAudit(context, tool, args, [], async () => {
+                const imageStart = Date.now();
+                const parsed = args;
+                context.onStatus?.(statusToolStage("imageGenerate", "planning"));
+                if (!parsed.prompt?.trim()) {
+                    context.onStatus?.(statusToolStage("imageGenerate", "failed"));
+                    return {
+                        ok: false,
+                        error: imageFailureMessage("invalid_prompt")
+                    };
+                }
+                if (!context.cloud?.imageGenerate) {
+                    context.onStatus?.(statusToolStage("imageGenerate", "failed"));
+                    return {
+                        ok: false,
+                        error: imageFailureMessage("config_missing", "imageGenerate requires cloud relay integration.")
+                    };
+                }
+                const requestedPath = parsed.pathRelativeToWorkspace?.trim();
+                const defaultStem = sanitizeFileStem(parsed.prompt) || "terry-image";
+                const safePath = requestedPath || `generated/${defaultStem}-${Date.now()}.png`;
+                const fullPath = resolveInWorkspace(context.workspacePath, safePath);
+                if (context.settings.dryRun) {
+                    context.onStatus?.(statusToolStage("imageGenerate", "completed"));
+                    return {
+                        ok: true,
+                        output: [
+                            "[dry-run] image generation preview",
+                            `Saved path: ${safePath}`
+                        ].join("\n"),
+                        files: [fullPath]
+                    };
+                }
+                let generated;
+                try {
+                    generated = await context.cloud.imageGenerate(parsed, (stage) => {
+                        if (stage === "requesting")
+                            context.onStatus?.(statusToolStage("imageGenerate", "requesting_model"));
+                        if (stage === "rendering")
+                            context.onStatus?.(statusToolStage("imageGenerate", "rendering"));
+                        if (stage === "received")
+                            context.onStatus?.(statusToolStage("imageGenerate", "receiving_payload"));
+                    });
+                }
+                catch (error) {
+                    context.onStatus?.(statusToolStage("imageGenerate", "failed"));
+                    const detail = error instanceof Error ? error.message : String(error);
+                    return {
+                        ok: false,
+                        error: imageFailureMessage(classifyImageCloudFailure(detail), detail)
+                    };
+                }
+                try {
+                    const ext = path.extname(fullPath) ? "" : `.${imageExtFromMime(generated.mimeType)}`;
+                    const writePath = ext ? `${fullPath}${ext}` : fullPath;
+                    context.onStatus?.(statusToolStage("imageGenerate", "saving_file"));
+                    await fs.mkdir(path.dirname(writePath), { recursive: true });
+                    await fs.writeFile(writePath, Buffer.from(generated.base64, "base64"));
+                    context.onStatus?.(statusToolStage("imageGenerate", "completed"));
+                    const relPath = path.relative(context.workspacePath, writePath);
+                    const elapsedMs = Date.now() - imageStart;
+                    const lines = [
+                        `Saved path: ${relPath}`,
+                        `Model: ${generated.model}`,
+                        `Mime type: ${generated.mimeType}`,
+                        `Total duration: ${(elapsedMs / 1000).toFixed(2)}s`
+                    ];
+                    if (generated.revisedPrompt?.trim()) {
+                        lines.push(`Revised prompt: ${generated.revisedPrompt.trim()}`);
+                    }
+                    return {
+                        ok: true,
+                        output: lines.join("\n"),
+                        files: [writePath]
+                    };
+                }
+                catch (error) {
+                    context.onStatus?.(statusToolStage("imageGenerate", "failed"));
+                    const message = error instanceof Error ? error.message : String(error);
+                    return {
+                        ok: false,
+                        error: imageFailureMessage("file_save", message)
+                    };
+                }
+            });
         case "memorySet":
             return withAudit(context, tool, args, [memoryFile()], async () => {
                 const parsed = args;

package/dist/types.d.ts

@@ -1,7 +1,7 @@
 export type PermissionLevel = "disabled" | "enabled" | "ask";
 export type AgentMode = "general" | "focus" | "builder";
-export type ExecutionMode = "plan" | "safe" | "autonomous";
-export type ToolName = "listDirectory" | "readFile" | "writeFile" | "searchInFiles" | "webSearch" | "gitStatus" | "gitDiff" | "runCommand" | "memorySet" | "memoryGet" | "openCalendarEvent" | "openGitHubIssue" | "openNotionPage" | "openLinearIssue" | "openSlackCompose" | "openEmail" | "openMapsDirections";
+export type ExecutionMode = "plan" | "safe" | "full" | "autonomous";
+export type ToolName = "listDirectory" | "readFile" | "writeFile" | "moveFile" | "searchInFiles" | "webSearch" | "gitStatus" | "gitDiff" | "runCommand" | "imageGenerate" | "memorySet" | "memoryGet" | "openCalendarEvent" | "openGitHubIssue" | "openNotionPage" | "openLinearIssue" | "openSlackCompose" | "openEmail" | "openMapsDirections";
 export type ToolArgsMap = {
     listDirectory: {
         pathRelativeToWorkspace?: string;
@@ -13,6 +13,10 @@ export type ToolArgsMap = {
         pathRelativeToWorkspace: string;
         content: string;
     };
+    moveFile: {
+        fromPathRelativeToWorkspace: string;
+        toPathRelativeToWorkspace: string;
+    };
     searchInFiles: {
         query: string;
     };
@@ -29,6 +33,13 @@ export type ToolArgsMap = {
         args?: string[];
         cwdRelativeToWorkspace?: string;
     };
+    imageGenerate: {
+        prompt: string;
+        size?: "1024x1024" | "1024x1536" | "1536x1024";
+        quality?: "standard" | "hd";
+        style?: "vivid" | "natural";
+        pathRelativeToWorkspace?: string;
+    };
     memorySet: {
         key: string;
         value: string;

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "terry-core",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "description": "Core policy, tooling, and orchestration modules for Terry Agent.",
   "license": "MIT",
   "author": "ELEVAREL",
   "homepage": "https://github.com/ELEVAREL/terry-agent",
   "repository": {
     "type": "git",
-    "url": "https://github.com/ELEVAREL/terry-agent.git",
+    "url": "git+https://github.com/ELEVAREL/terry-agent.git",
     "directory": "packages/terry-core"
   },
   "type": "module",