morpheus-cli 0.9.24 → 0.9.31

package/dist/runtime/__tests__/gws-sync.test.js

@@ -0,0 +1,69 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import fs from 'fs-extra';
+import path from 'path';
+import { syncGwsSkills } from '../gws-sync.js';
+import { ConfigManager } from '../../config/manager.js';
+import { calculateMd5 } from '../hash-utils.js';
+import { tmpdir } from 'os';
+vi.mock('../../config/manager.js');
+vi.mock('../display.js', () => ({
+    DisplayManager: {
+        getInstance: () => ({
+            log: vi.fn(),
+        }),
+    },
+}));
+describe('GwsSync', () => {
+    let mockDestDir;
+    let mockHashesFile;
+    const mockSourceDir = path.join(process.cwd(), 'gws-skills', 'skills');
+    beforeEach(async () => {
+        vi.resetAllMocks();
+        // Create a truly temporary directory for this test run
+        mockDestDir = path.join(tmpdir(), `morpheus-test-skills-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+        mockHashesFile = path.join(mockDestDir, '.gws-hashes.json');
+        vi.mocked(ConfigManager.getInstance).mockReturnValue({
+            getGwsConfig: () => ({ enabled: true }),
+        });
+        await fs.ensureDir(mockDestDir);
+    });
+    afterEach(async () => {
+        await fs.remove(mockDestDir);
+    });
+    it('should copy new skills if destination does not exist', async () => {
+        if (!(await fs.pathExists(mockSourceDir))) {
+            console.warn('Skipping test: gws-skills/skills not found');
+            return;
+        }
+        await syncGwsSkills(mockDestDir);
+        const skills = await fs.readdir(mockSourceDir);
+        if (skills.length > 0) {
+            const firstSkill = skills[0];
+            expect(await fs.pathExists(path.join(mockDestDir, firstSkill, 'SKILL.md'))).toBe(true);
+            const metadata = await fs.readJson(mockHashesFile);
+            expect(metadata.skills[firstSkill]).toBeDefined();
+        }
+    });
+    it('should not overwrite customized skills', async () => {
+        if (!(await fs.pathExists(mockSourceDir)))
+            return;
+        const skills = await fs.readdir(mockSourceDir);
+        if (skills.length === 0)
+            return;
+        const skillName = skills[0];
+        const destPath = path.join(mockDestDir, skillName, 'SKILL.md');
+        // 1. Initial sync to set baseline
+        await syncGwsSkills(mockDestDir);
+        const originalMetadata = await fs.readJson(mockHashesFile);
+        const originalHash = originalMetadata.skills[skillName];
+        // 2. User modifies the file
+        await fs.writeFile(destPath, 'USER CUSTOMIZATION');
+        const customHash = calculateMd5('USER CUSTOMIZATION');
+        expect(customHash).not.toBe(originalHash);
+        // 3. Sync again
+        await syncGwsSkills(mockDestDir);
+        // 4. Verify file was preserved
+        const content = await fs.readFile(destPath, 'utf-8');
+        expect(content).toBe('USER CUSTOMIZATION');
+    });
+});

package/dist/runtime/gws-sync.js

@@ -0,0 +1,102 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { PATHS } from '../config/paths.js';
+import { ConfigManager } from '../config/manager.js';
+import { calculateFileMd5 } from './hash-utils.js';
+import { DisplayManager } from './display.js';
+import chalk from 'chalk';
+import { execSync } from 'child_process';
+/**
+ * Checks if a binary is available in the system PATH.
+ */
+function isBinaryAvailable(name) {
+    try {
+        const command = process.platform === 'win32' ? `where ${name}` : `which ${name}`;
+        execSync(command, { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Synchronizes built-in Google Workspace skills to the user's skills directory.
+ * Uses MD5 hashes to avoid overwriting user customizations.
+ */
+export async function syncGwsSkills(destOverride) {
+    const config = ConfigManager.getInstance().getGwsConfig();
+    if (config.enabled === false)
+        return;
+    const display = DisplayManager.getInstance();
+    const sourceDir = path.join(process.cwd(), 'gws-skills', 'skills');
+    const destDir = destOverride ?? PATHS.skills;
+    const hashesFile = path.join(destDir, '.gws-hashes.json');
+    // Check if gws binary is available
+    if (!isBinaryAvailable('gws')) {
+        display.log(`⚠️ Google Workspace CLI (gws) not found in system PATH. GWS skills will not function.`, { source: 'GwsSync', level: 'warning' });
+    }
+    // Validate Service Account JSON if provided
+    if (config.service_account_json) {
+        if (!(await fs.pathExists(config.service_account_json))) {
+            display.log(`⚠️ Google Workspace Service Account JSON not found at: ${chalk.yellow(config.service_account_json)}. GWS tools may fail to authenticate.`, { source: 'GwsSync', level: 'warning' });
+        }
+    }
+    if (!(await fs.pathExists(sourceDir))) {
+        // Silent skip if source doesn't exist (e.g. in some production environments)
+        return;
+    }
+    try {
+        let metadata = { skills: {}, last_sync: new Date().toISOString() };
+        if (await fs.pathExists(hashesFile)) {
+            metadata = await fs.readJson(hashesFile);
+        }
+        const builtInSkills = await fs.readdir(sourceDir);
+        let newCount = 0;
+        let updatedCount = 0;
+        let skippedCount = 0;
+        for (const skillName of builtInSkills) {
+            const skillSourcePath = path.join(sourceDir, skillName, 'SKILL.md');
+            const skillDestPath = path.join(destDir, skillName, 'SKILL.md');
+            if (!(await fs.pathExists(skillSourcePath)))
+                continue;
+            const sourceHash = await calculateFileMd5(skillSourcePath);
+            if (!(await fs.pathExists(skillDestPath))) {
+                // New skill
+                await fs.ensureDir(path.dirname(skillDestPath));
+                await fs.copy(skillSourcePath, skillDestPath);
+                metadata.skills[skillName] = sourceHash;
+                newCount++;
+            }
+            else {
+                // Existing skill - check for customization
+                const destHash = await calculateFileMd5(skillDestPath);
+                const lastKnownHash = metadata.skills[skillName];
+                if (destHash === sourceHash) {
+                    // Already up to date
+                    continue;
+                }
+                if (destHash === lastKnownHash) {
+                    // Unmodified default, update to latest
+                    await fs.copy(skillSourcePath, skillDestPath);
+                    metadata.skills[skillName] = sourceHash;
+                    updatedCount++;
+                }
+                else {
+                    // User modified or unknown state, preserve
+                    skippedCount++;
+                }
+            }
+        }
+        metadata.last_sync = new Date().toISOString();
+        await fs.writeJson(hashesFile, metadata, { spaces: 2 });
+        if (newCount > 0 || updatedCount > 0) {
+            display.log(`🔧 Google Workspace skills initialized: ${chalk.green(newCount)} new, ${chalk.blue(updatedCount)} updated${skippedCount > 0 ? `, ${chalk.yellow(skippedCount)} customized (skipped)` : ''}`, { source: 'GwsSync', level: 'info' });
+        }
+    }
+    catch (error) {
+        display.log(`Failed to sync Google Workspace skills: ${error instanceof Error ? error.message : String(error)}`, {
+            source: 'GwsSync',
+            level: 'error',
+        });
+    }
+}

package/dist/runtime/hash-utils.js

@@ -0,0 +1,15 @@
+import crypto from 'crypto';
+import fs from 'fs-extra';
+/**
+ * Calculates the MD5 hash of a string.
+ */
+export function calculateMd5(content) {
+    return crypto.createHash('md5').update(content).digest('hex');
+}
+/**
+ * Calculates the MD5 hash of a file.
+ */
+export async function calculateFileMd5(filePath) {
+    const content = await fs.readFile(filePath, 'utf-8');
+    return calculateMd5(content);
+}

package/dist/runtime/hot-reload.js

@@ -8,6 +8,7 @@
 import { ConfigManager } from '../config/manager.js';
 import { DisplayManager } from './display.js';
 import { SubagentRegistry } from './subagents/registry.js';
+import { SkillRegistry } from './skills/index.js';
 let currentOracle = null;
 /**
  * Register the current Oracle instance for hot-reload.
@@ -36,7 +37,10 @@ export async function hotReloadConfig() {
         // 1. Reload configuration from disk
         await ConfigManager.getInstance().load();
         display.log('Configuration reloaded from disk', { source: 'HotReload', level: 'info' });
-        // 2. Reinitialize Oracle if it exists
+        // 2. Reload skills
+        await SkillRegistry.getInstance().reload();
+        display.log('Skills reloaded from disk', { source: 'HotReload', level: 'info' });
+        // 3. Reinitialize Oracle if it exists
         if (currentOracle && typeof currentOracle.reinitialize === 'function') {
             await currentOracle.reinitialize();
             reinitialized.push('Oracle');

package/dist/runtime/oracle.js

@@ -340,6 +340,7 @@ Always call time_verifier first, then use the resolved date in your tool call or
 11. If a delegation is rejected as "not atomic", immediately split into smaller delegations and retry.
 12. When the user message contains @link, @neo, @apoc, or @trinity (case-insensitive), delegate to that specific agent. The mention is an explicit routing directive — respect it even if another agent might also handle the request.
 13. Smiths also have names and could be called by @smithname — respect this as an explicit routing directive as well.
+14. Delegate Google Workspace (GWS) tasks (Sheets, Docs, Calendar, Drive, Gmail) to the Apoc agent using the \`apoc_delegate\` tool.
 
 ## Delegation quality ##
 - Write delegation input in the same language requested by the user.

package/dist/runtime/scaffold.js

@@ -6,6 +6,7 @@ import { DEFAULT_MCP_TEMPLATE } from '../types/mcp.js';
 import chalk from 'chalk';
 import ora from 'ora';
 import { migrateConfigFile } from './migration.js';
+import { syncGwsSkills } from './gws-sync.js';
 const SKILLS_README = `# Morpheus Skills
 
 This folder contains custom skills for Morpheus.
@@ -72,6 +73,7 @@ export async function scaffold() {
             fs.ensureDir(PATHS.commands),
             fs.ensureDir(PATHS.skills),
             fs.ensureDir(PATHS.docs),
+            fs.ensureDir(PATHS.gws),
         ]);
         // Migrate config.yaml -> zaion.yaml if needed
         await migrateConfigFile();
@@ -92,6 +94,8 @@ export async function scaffold() {
         if (!(await fs.pathExists(skillsReadme))) {
             await fs.writeFile(skillsReadme, SKILLS_README, 'utf-8');
         }
+        // Sync Google Workspace skills
+        await syncGwsSkills();
         spinner.succeed('Morpheus environment ready at ' + chalk.cyan(PATHS.root));
     }
     catch (error) {

package/dist/runtime/skills/loader.js

@@ -12,67 +12,22 @@
  */
 import fs from 'fs';
 import path from 'path';
+import yaml from 'js-yaml';
 import { SkillMetadataSchema } from './schema.js';
 import { DisplayManager } from '../display.js';
 const SKILL_MD = 'SKILL.md';
 const MAX_SKILL_MD_SIZE = 50 * 1024; // 50KB
 const FRONTMATTER_REGEX = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/;
 /**
- * Simple YAML frontmatter parser
- * Handles basic key: value pairs and arrays
+ * Parses YAML frontmatter using js-yaml
  */
-function parseFrontmatter(yaml) {
-    const result = {};
-    const lines = yaml.split('\n');
-    let currentKey = null;
-    let currentArray = null;
-    for (const line of lines) {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith('#'))
-            continue;
-        // Check for array item (indented with -)
-        if (trimmed.startsWith('- ') && currentKey && currentArray !== null) {
-            currentArray.push(trimmed.slice(2).trim().replace(/^["']|["']$/g, ''));
-            continue;
-        }
-        // Check for key: value
-        const colonIndex = line.indexOf(':');
-        if (colonIndex > 0) {
-            // Save previous array if exists
-            if (currentKey && currentArray !== null && currentArray.length > 0) {
-                result[currentKey] = currentArray;
-            }
-            currentArray = null;
-            const key = line.slice(0, colonIndex).trim();
-            const value = line.slice(colonIndex + 1).trim();
-            currentKey = key;
-            if (value === '') {
-                // Could be start of array
-                currentArray = [];
-            }
-            else if (value === 'true') {
-                result[key] = true;
-            }
-            else if (value === 'false') {
-                result[key] = false;
-            }
-            else if (/^\d+$/.test(value)) {
-                result[key] = parseInt(value, 10);
-            }
-            else if (/^\d+\.\d+$/.test(value)) {
-                result[key] = parseFloat(value);
-            }
-            else {
-                // Remove quotes if present
-                result[key] = value.replace(/^["']|["']$/g, '');
-            }
-        }
+function parseFrontmatter(yamlContent) {
+    try {
+        return yaml.load(yamlContent);
     }
-    // Save last array if exists
-    if (currentKey && currentArray !== null && currentArray.length > 0) {
-        result[currentKey] = currentArray;
+    catch (err) {
+        throw new Error(`YAML parse error: ${err instanceof Error ? err.message : String(err)}`);
     }
-    return result;
 }
 export class SkillLoader {
     skillsDir;

package/dist/runtime/skills/registry.js

@@ -114,7 +114,11 @@ export class SkillRegistry {
 
 ${skillList}
 
-Use the \`load_skill\` tool when you need detailed instructions for handling a specific type of request.`;
+MANDATORY SKILL WORKFLOW:
+1. If a user request matches any skill above, you MUST call \`load_skill\` BEFORE calling any delegation tool (apoc_delegate, neo_delegate, etc.).
+2. After loading the skill, include the skill content in the \`context\` parameter when delegating to a subagent.
+3. NEVER delegate a GWS/Google Workspace task without first loading the relevant skill — the subagent needs the exact CLI syntax from the skill instructions.
+4. Example: User asks "create a Google Calendar event" → call \`load_skill("gws-calendar-insert")\` → then call \`apoc_delegate\` with the skill content in \`context\`.`;
     }
     /**
      * Get skill names for tool description

package/dist/runtime/skills/schema.js

@@ -22,4 +22,4 @@ export const SkillMetadataSchema = z.object({
     enabled: z.boolean().optional().default(true),
     tags: z.array(z.string().max(32)).max(10).optional(),
     examples: z.array(z.string().max(200)).max(5).optional(),
-});
+}).passthrough();

package/dist/runtime/skills/tool.js

@@ -55,7 +55,14 @@ function buildLoadSkillDescription() {
     const skillList = enabled.length > 0
         ? enabled.map(s => `- ${s.name}: ${s.description}`).join('\n')
         : '(no skills available)';
-    return `Load a skill's instructions into your context. After loading, follow the instructions to handle the request using your existing tools or delegate to Agents.
+    return `MANDATORY: Load a skill's expert instructions BEFORE delegating a task that matches an available skill.
+
+CRITICAL: For Google Workspace (GWS) tasks, you MUST:
+1. Call load_skill with the matching gws-* skill name FIRST
+2. Then delegate to apoc_delegate, passing the loaded skill content in the "context" parameter
+3. NEVER delegate GWS tasks without loading the skill — Apoc needs the exact CLI syntax
+
+After loading, the skill content tells you (and the subagent) the exact commands, resources, and parameters to use.
 
 Available skills:
 ${skillList}`;

package/dist/runtime/subagents/apoc.js

@@ -8,6 +8,8 @@ import { instrumentDevKitTools } from "./devkit-instrument.js";
 import { extractRawUsage, persistAgentMessage, buildAgentResult, emitToolAuditEvents } from "./utils.js";
 import { buildDelegationTool } from "../tools/delegation-utils.js";
 import { SubagentRegistry } from "./registry.js";
+import { USER_HOME } from "../../config/paths.js";
+import { SkillRegistry } from "../skills/index.js";
 /**
  * Apoc is a subagent of Oracle specialized in devtools operations.
  * It receives delegated tasks from Oracle and executes them using DevKit tools
@@ -34,6 +36,35 @@ export class Apoc {
     static setSessionId(sessionId) {
         Apoc.currentSessionId = sessionId;
     }
+    /** Update tool description with available skills */
+    static async refreshDelegateCatalog() {
+        if (Apoc._delegateTool) {
+            const skills = SkillRegistry.getInstance().getEnabled();
+            const gwsSkills = skills.filter(s => s.name.startsWith('gws-') || s.name.startsWith('recipe-'));
+            let description = `Delegate a devtools task to Apoc, the specialized development subagent.
+
+This tool enqueues a background task and returns an acknowledgement with task id.
+Do not expect final execution output in the same response.
+Each task must contain a single atomic action with a clear expected result.
+
+Use this tool when the user asks for ANY of the following:
+- File operations: read, write, create, delete files or directories
+- Shell commands: run scripts, execute commands, check output
+- Git: status, log, diff, commit, push, pull, clone, branch
+- Package management: npm install/update/audit, yarn, package.json inspection
+- Process management: list processes, kill processes, check ports
+- Network: ping hosts, curl URLs, DNS lookups
+- System info: environment variables, OS info, disk space, memory
+- Internet search: search DuckDuckGo and verify facts by reading at least 3 sources via browser_navigate before reporting results.
+- Browser automation: navigate websites (JS/SPA), inspect DOM, click elements, fill forms. Apoc will ask for missing user input (e.g. credentials, form fields) before proceeding.
+- Google Workspace (GWS) operations: manage Sheets, Docs, Calendar, Drive, Gmail using the \`gws\` CLI. Apoc will ensure proper authentication is set for each command and report any errors encountered.`;
+            if (gwsSkills.length > 0) {
+                description += '\n\nAvailable Google Workspace (GWS) and Recipe capabilities:\n' +
+                    gwsSkills.map(s => `- ${s.name}: ${s.description}`).join('\n');
+            }
+            Apoc._delegateTool.description = description;
+        }
+    }
     static getInstance(config) {
         if (!Apoc.instance) {
             Apoc.instance = new Apoc(config);
@@ -45,9 +76,10 @@ export class Apoc {
                 bgClass: 'bg-amber-50 dark:bg-amber-900/10',
                 badgeClass: 'bg-amber-100 text-amber-700 dark:bg-amber-900/40 dark:text-amber-300',
                 instance: Apoc.instance,
-                hasDynamicDescription: false,
+                hasDynamicDescription: true,
                 isMultiInstance: false,
                 setSessionId: (id) => Apoc.setSessionId(id),
+                refreshCatalog: () => Apoc.refreshDelegateCatalog(),
             });
         }
         return Apoc.instance;
@@ -84,6 +116,120 @@ export class Apoc {
             throw new ProviderError(apocConfig.provider, err, "Apoc subagent initialization failed");
         }
     }
+    /**
+     * Auto-resolve relevant skills for a task by matching keywords to skill names.
+     * Returns the concatenated skill content to inject into Apoc's system prompt.
+     */
+    resolveSkillsForTask(task, context) {
+        const registry = SkillRegistry.getInstance();
+        const enabled = registry.getEnabled();
+        if (enabled.length === 0)
+            return '';
+        const combined = `${task} ${context || ''}`.toLowerCase();
+        // Check if skill content was already provided in the context (Oracle loaded it)
+        if (context && context.includes('Loaded skill:'))
+            return '';
+        // GWS keyword → skill name mapping
+        const gwsKeywordMap = {
+            'tasks': ['gws-tasks'],
+            'task': ['gws-tasks'],
+            'google tasks': ['gws-tasks'],
+            'calendar': ['gws-calendar', 'gws-calendar-insert', 'gws-calendar-agenda'],
+            'evento': ['gws-calendar', 'gws-calendar-insert'],
+            'event': ['gws-calendar', 'gws-calendar-insert'],
+            'agenda': ['gws-calendar-agenda', 'gws-calendar'],
+            'gmail': ['gws-gmail', 'gws-gmail-send'],
+            'email': ['gws-gmail', 'gws-gmail-send'],
+            'e-mail': ['gws-gmail', 'gws-gmail-send'],
+            'enviar email': ['gws-gmail-send'],
+            'send email': ['gws-gmail-send'],
+            'forward': ['gws-gmail-forward'],
+            'encaminhar': ['gws-gmail-forward'],
+            'reply': ['gws-gmail-reply'],
+            'responder email': ['gws-gmail-reply'],
+            'drive': ['gws-drive', 'gws-drive-upload'],
+            'upload': ['gws-drive-upload'],
+            'docs': ['gws-docs', 'gws-docs-write'],
+            'documento': ['gws-docs', 'gws-docs-write'],
+            'document': ['gws-docs', 'gws-docs-write'],
+            'sheets': ['gws-sheets'],
+            'planilha': ['gws-sheets'],
+            'spreadsheet': ['gws-sheets'],
+            'meet': ['gws-meet'],
+            'reunião': ['gws-meet'],
+            'meeting': ['gws-meet'],
+            'forms': ['gws-forms'],
+            'formulário': ['gws-forms'],
+            'keep': ['gws-keep'],
+            'nota': ['gws-keep'],
+            'note': ['gws-keep'],
+            'chat': ['gws-chat', 'gws-chat-send'],
+            'classroom': ['gws-classroom'],
+        };
+        const matchedSkills = new Set();
+        // Check if task involves GWS at all
+        const isGwsTask = combined.includes('gws') || combined.includes('google') ||
+            Object.keys(gwsKeywordMap).some(kw => combined.includes(kw));
+        if (!isGwsTask)
+            return '';
+        // Find matching skills by keyword
+        for (const [keyword, skillNames] of Object.entries(gwsKeywordMap)) {
+            if (combined.includes(keyword)) {
+                for (const name of skillNames) {
+                    matchedSkills.add(name);
+                }
+            }
+        }
+        // If GWS task but no specific match, try to match by skill name fragments
+        if (matchedSkills.size === 0 && isGwsTask) {
+            for (const skill of enabled) {
+                if (skill.name.startsWith('gws-')) {
+                    const service = skill.name.replace('gws-', '').replace(/-/g, ' ');
+                    if (combined.includes(service)) {
+                        matchedSkills.add(skill.name);
+                    }
+                }
+            }
+        }
+        // Also check recipe skills
+        for (const skill of enabled) {
+            if (skill.name.startsWith('recipe-')) {
+                const recipe = skill.name.replace('recipe-', '').replace(/-/g, ' ');
+                if (combined.includes(recipe)) {
+                    matchedSkills.add(skill.name);
+                }
+            }
+        }
+        if (matchedSkills.size === 0)
+            return '';
+        // Load skill content (limit to 3 most relevant)
+        const skillContents = [];
+        let count = 0;
+        for (const name of matchedSkills) {
+            if (count >= 3)
+                break;
+            const skill = registry.get(name);
+            if (skill?.enabled && skill.content) {
+                skillContents.push(`━━━ SKILL: ${skill.name} ━━━\n${skill.content}`);
+                count++;
+            }
+        }
+        if (skillContents.length === 0)
+            return '';
+        this.display.log(`Auto-injected ${skillContents.length} skill(s) for task: ${[...matchedSkills].slice(0, 3).join(', ')}`, {
+            source: 'Apoc',
+            level: 'info',
+        });
+        return `\n\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+LOADED SKILLS — FOLLOW THESE INSTRUCTIONS
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+The following skill instructions tell you EXACTLY how to execute this task.
+Use \`gws schema <resource>.<method>\` to discover required params before calling any method.
+Do NOT guess command syntax — follow the skill instructions below.
+
+${skillContents.join('\n\n')}`;
+    }
     /**
      * Execute a devtools task delegated by Oracle.
      * @param task Natural language task description
@@ -99,6 +245,8 @@ export class Apoc {
             source: "Apoc",
         });
         const personality = this.config.apoc?.personality || 'pragmatic_dev';
+        // Auto-resolve and inject relevant skill content for the task
+        const skillSection = this.resolveSkillsForTask(task, context);
         const systemMessage = new SystemMessage(`
 You are Apoc, ${personality === 'pragmatic_dev' ? 'a pragmatic and methodical developer' : personality}, a high-reliability execution and verification subagent inside the Morpheus system.
 
@@ -117,6 +265,10 @@ CORE PRINCIPLES
 • Prefer authoritative sources over secondary commentary.
 • Prefer verification over assumption.
 • Explicitly measure and report confidence.
+• You have the capability to execute \`gws\` CLI commands for Google Workspace operations (Sheets, Calendar, Drive, etc.).
+• **CRITICAL GWS AUTH**: Every time you run a \`gws\` command, you MUST ensure \`GOOGLE_WORKSPACE_CLI_CREDENTIALS_FILE\` is set to the absolute path of your credentials file: \`${USER_HOME}/.morpheus/gws/credentials.json\` (or the equivalent absolute path on the current OS). If not already set in your environment, prepend the command with the export (e.g., \`export GOOGLE_WORKSPACE_CLI_CREDENTIALS_FILE=... && gws ...\` on Linux/macOS or \`$env:GOOGLE_WORKSPACE_CLI_CREDENTIALS_FILE='...'; gws ...\` on Windows).
+• If the \`gws\` command fails, report the error detail. If the tool is not installed, inform the user clearly.
+• **IMPORTANT**: When skill instructions are loaded below, follow them EXACTLY. Do NOT guess CLI syntax — use \`gws schema\` to discover params first.${skillSection}
 
 If reliable evidence cannot be obtained:
 State clearly:
@@ -312,6 +464,7 @@ Use this tool when the user asks for ANY of the following:
 - System info: environment variables, OS info, disk space, memory
 - Internet search: search DuckDuckGo and verify facts by reading at least 3 sources via browser_navigate before reporting results.
 - Browser automation: navigate websites (JS/SPA), inspect DOM, click elements, fill forms. Apoc will ask for missing user input (e.g. credentials, form fields) before proceeding.
+- Google Workspace (GWS) operations: manage Sheets, Docs, Calendar, Drive, Gmail using the \`gws\` CLI. Apoc will ensure proper authentication is set for each command and report any errors encountered.
 
 Provide a clear natural language task description. Optionally provide context
 from the current conversation to help Apoc understand the broader goal.`,

package/dist/runtime/subagents/devkit-instrument.js

@@ -1,5 +1,6 @@
 import { AuditRepository } from '../audit/repository.js';
 import { DisplayManager } from '../display.js';
+import { ConfigManager } from '../../config/manager.js';
 const display = DisplayManager.getInstance();
 /**
  * Wraps a StructuredTool to record audit events on each invocation.
@@ -12,6 +13,18 @@ function instrumentTool(tool, getSessionId, getAgent) {
         const startMs = Date.now();
         const sessionId = getSessionId() ?? 'unknown';
         const agent = getAgent();
+        // Inject GWS credentials if it's a shell tool and command starts with 'gws'
+        if ((tool.name === 'execShell' || tool.name === 'execCommand') && input?.command?.trim().startsWith('gws')) {
+            const gwsConfig = ConfigManager.getInstance().getGwsConfig();
+            if (gwsConfig.service_account_json) {
+                input.env = {
+                    ...(input.env || {}),
+                    GOOGLE_APPLICATION_CREDENTIALS: gwsConfig.service_account_json,
+                    GOOGLE_WORKSPACE_CLI_CREDENTIALS_FILE: gwsConfig.service_account_json,
+                };
+                display.log(`Injected GWS credentials into environment for tool ${tool.name}`, { source: 'DevKitInstrumentation', level: 'debug' });
+            }
+        }
         display.startActivity(agent, `Executing tool: ${tool.name}`);
         try {
             const result = await original(input, runManager);

package/dist/types/config.js

@@ -108,5 +108,8 @@ export const DEFAULT_CONFIG = {
         task_timeout_ms: 60000,
         entries: [],
     },
+    gws: {
+        enabled: true,
+    },
     verbose_mode: true,
 };