fraim-hub 2.0.335 → 2.0.338

package/dist/registry/scripts/learning/entry-format.js

@@ -0,0 +1,27 @@
+'use strict';
+
+// Read the shared author's current entry format for identity and update guards.
+function learningEntryBlocks(body) {
+    const headings = [...body.matchAll(/^#{2,6}\s+\[P-[A-Z]+\].*$/gm)];
+    return headings.map((heading, index) => {
+        const start = heading.index;
+        const next = headings[index + 1]?.index ?? body.length;
+        const ownDepth = heading[0].match(/^#+/)[0].length;
+        const afterHeading = start + heading[0].length;
+        const shallower = [...body.slice(afterHeading, next).matchAll(/^(#{1,6})\s+.*$/gm)].find(m => m[1].length <= ownDepth);
+        const limit = shallower ? afterHeading + shallower.index : next;
+        const text = body.slice(start, limit).trimEnd();
+        return { start, end: start + text.length, text, id: text.match(/^\*\*Id\*\*:\s*(L-[a-f0-9]{10})\s*$/m)?.[1] ?? null };
+    });
+}
+
+function learningEntryMetadata(content) {
+    const metadata = {};
+    for (const match of content.matchAll(/^\*\*(Recurrences|First recorded|First synthesized)\*\*:\s*([^\r\n]+)$/gm)) {
+        if (metadata[match[1]] !== undefined && metadata[match[1]] !== match[2]) throw new Error('entry-metadata-conflict');
+        metadata[match[1]] = match[2];
+    }
+    return metadata;
+}
+
+module.exports = { learningEntryMetadata, learningEntryBlocks };

package/dist/registry/scripts/learning/learning-domains.json

@@ -0,0 +1,78 @@
+{
+  "schemaVersion": 1,
+  "mapVersion": 1,
+  "domains": [
+    "engineering",
+    "product",
+    "go-to-market",
+    "people-ops",
+    "finance",
+    "legal",
+    "compliance",
+    "customer",
+    "company-building",
+    "operations"
+  ],
+  "jobDomainMap": {
+    "product-building": "engineering",
+    "dev-ops": "engineering",
+    "quality-assurance": "engineering",
+    "migration": "engineering",
+    "replicate": "engineering",
+    "reviewer": "engineering",
+    "security": "engineering",
+    "delivery-ops": "engineering",
+    "salesforce": "engineering",
+    "ai-engineering": "engineering",
+    "product-management": "product",
+    "customer-development": "product",
+    "brainstorming": "product",
+    "marketing": "go-to-market",
+    "branding": "go-to-market",
+    "sales": "go-to-market",
+    "go-to-market": "go-to-market",
+    "business-development": "go-to-market",
+    "commercial-ops": "go-to-market",
+    "people-ops": "people-ops",
+    "inclusion-ops": "people-ops",
+    "career": "people-ops",
+    "finance": "finance",
+    "invoicing": "finance",
+    "banking": "finance",
+    "legal": "legal",
+    "compliance": "compliance",
+    "customer-success": "customer",
+    "customer-communication": "customer",
+    "company-creation": "company-building",
+    "bootstrap": "company-building",
+    "fundraising": "company-building",
+    "business-ops": "operations",
+    "procurement": "operations",
+    "project-management": "operations"
+  },
+  "globalJobCategories": [
+    "manager",
+    "fraim",
+    "1-1",
+    "coaching",
+    "delegation",
+    "hiring",
+    "productivity",
+    "project-setup",
+    "setup-guardrails",
+    "team-learning",
+    "verification"
+  ],
+  "domainVoice": {
+    "engineering": "Precise and technical; file paths, commands, and test names are appropriate.",
+    "product": "Product and user-outcome language; behavior and flow, not code symbols.",
+    "go-to-market": "Marketing and sales language; campaigns, funnels, messaging, audience.",
+    "people-ops": "Plain HR and recruiting language; no engineering jargon.",
+    "finance": "Finance and accounting language; figures, close, forecasts.",
+    "legal": "Contract and IP language; obligations, clauses, risk.",
+    "compliance": "Controls, evidence, and regulation language.",
+    "customer": "Customer-relationship and support language.",
+    "company-building": "Founder and operations language; setup, entity, funding.",
+    "operations": "Business-operations language; process, vendors, planning, coordination."
+  }
+}

package/dist/src/ai-hub/attachment-store.js

@@ -1,4 +1,37 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -30,7 +63,6 @@ exports.safeAttachmentMetaPath = safeAttachmentMetaPath;
  * path its own file-read tool opens.
  */
 const path_1 = __importDefault(require("path"));
-const sharp_1 = __importDefault(require("sharp"));
 /** Accepted upload MIME types (spec R1/R11). */
 exports.ACCEPTED_ATTACHMENT_MIME_TYPES = new Set([
     'image/png',
@@ -90,8 +122,9 @@ function pdfContainsScriptMarker(buffer) {
 async function sanitizeAttachmentBuffer(buffer, mimeType) {
     if (IMAGE_MIME_TYPES.has(mimeType)) {
         try {
+            const sharp = (await Promise.resolve().then(() => __importStar(require('sharp')))).default;
             const format = mimeType === 'image/jpeg' ? 'jpeg' : mimeType === 'image/gif' ? 'gif' : 'png';
-            return await (0, sharp_1.default)(buffer).toFormat(format).toBuffer();
+            return await sharp(buffer).toFormat(format).toBuffer();
         }
         catch (err) {
             throw new AttachmentRejectedError(415, `Not a valid ${mimeType} image.`);

package/dist/src/ai-hub/desktop-main.js

@@ -11,6 +11,7 @@ const electron_1 = require("electron");
 const path_1 = __importDefault(require("path"));
 const fs_1 = __importDefault(require("fs"));
 const server_1 = require("./server");
+const native_voice_input_1 = require("./native-voice-input");
 const cert_store_1 = require("./cert-store");
 const office_sideload_1 = require("./office-sideload");
 const office_setup_policy_1 = require("./office-setup-policy");
@@ -672,6 +673,10 @@ async function launchDesktopShell(options) {
             return result.canceled || result.filePaths.length === 0 ? null : result.filePaths[0];
         },
         restartToLatest: restartToLatestNow,
+        voiceInput: (0, native_voice_input_1.createNativeVoiceInputController)({
+            getWindow: () => mainWindow,
+            sendActionToFirstResponder: (action) => electron_1.Menu.sendActionToFirstResponder(action),
+        }),
         hubMainDiagnostics: {
             snapshot: () => (0, hub_main_diagnostics_1.getHubMainDiagnosticsSnapshot)(buildDesktopDebugSnapshot(runtimeId)),
         },

package/dist/src/ai-hub/managed-browser.js

@@ -110,15 +110,27 @@ function buildBrowserLaunchArgs(opts) {
  * baked into any registry job or skill. Returns '' when the shared browser is not
  * available (so the note only appears when there is something to connect to).
  */
-function buildBrowserContextNote(cdpEndpoint, hubBaseUrl) {
+function buildBrowserContextNote(cdpEndpoint, hubBaseUrl, conversationId, page) {
     if (!cdpEndpoint || !hubBaseUrl)
         return '';
+    const trimmedConversationId = typeof conversationId === 'string' ? conversationId.trim() : '';
+    const pageGuidance = trimmedConversationId
+        ? [
+            `Browser work for this Hub conversation must use the conversation page for \`${trimmedConversationId}\`, not the globally active tab.`,
+            `Before using a browser, ensure it is running and get this conversation's page: \`POST ${hubBaseUrl}/api/ai-hub/browser/start\` with JSON body \`{"conversationId":"${trimmedConversationId}"}\` (idempotent - it reuses the running browser and this conversation's page, or relaunches/recreates them if they were closed).`,
+            page?.targetId
+                ? `Current allocated page target: \`${page.targetId}\`${page.webSocketDebuggerUrl ? ` (${page.webSocketDebuggerUrl})` : ''}.`
+                : 'Use the returned `page.targetId` / `page.webSocketDebuggerUrl` from that endpoint when your browser tooling lets you choose a CDP target.',
+        ]
+        : [
+            `Before using a browser, ensure it is running: \`POST ${hubBaseUrl}/api/ai-hub/browser/start\` (idempotent - it reuses the running browser, or relaunches it if it was closed).`,
+        ];
     return [
         '',
-        '[FRAIM shared browser] A persistent shared browser is available — use it instead of launching your own.',
-        `Before using a browser, ensure it is running: \`POST ${hubBaseUrl}/api/ai-hub/browser/start\` (idempotent — it reuses the running browser, or relaunches it if it was closed).`,
-        `Then drive the shared browser at ${cdpEndpoint}: your Playwright/browser tools are pointed at it on supported agents; if your tools would otherwise open their own browser, connect to the shared one with \`connectOverCDP("${cdpEndpoint}")\` and reuse its existing context/tab.`,
-        'Never close the shared browser or sign me out. If a site needs login, open it there and ask me to log in — the session persists to your next turn.',
+        '[FRAIM shared browser] A persistent shared browser is available; use it instead of launching your own.',
+        ...pageGuidance,
+        `Then drive the shared browser at ${cdpEndpoint}: your Playwright/browser tools are pointed at it on supported agents; if your tools would otherwise open their own browser, connect to the shared one with \`connectOverCDP("${cdpEndpoint}")\` and use the conversation page target instead of an arbitrary existing tab.`,
+        'Never close the shared browser or sign me out. If a site needs login, open it there and ask me to log in; the session persists to your next turn.',
     ].join('\n');
 }
 /** Default persistent profile directory — sandboxed from the user's daily browser. */
@@ -168,6 +180,7 @@ class ManagedBrowser {
         this.child = null;
         this.ownsProcess = false;
         this.resolved = null;
+        this.conversationPages = new Map();
         this.opts = opts;
         this.channel = opts.channel || 'auto';
         this.port = opts.port || DEFAULT_PORT;
@@ -180,6 +193,11 @@ class ManagedBrowser {
     probe() {
         return this.opts.probeFn ? this.opts.probeFn(this.cdpEndpoint()) : probeCdpEndpoint(this.cdpEndpoint());
     }
+    async cdpRequest(requestPath, method = 'GET') {
+        if (this.opts.cdpRequestFn)
+            return this.opts.cdpRequestFn(requestPath, method);
+        return cdpJsonRequest(this.cdpEndpoint(), requestPath, method);
+    }
     /** Live check — does a Chromium CDP endpoint answer on the port right now. */
     isRunning() {
         return this.probe();
@@ -232,6 +250,71 @@ class ManagedBrowser {
         await this.waitForRunning();
         return { endpoint: this.cdpEndpoint(), reused: false, executable: exe.path, channel: exe.channel };
     }
+    async listPageTargets() {
+        const raw = await this.cdpRequest('/json/list');
+        if (!Array.isArray(raw))
+            return [];
+        return raw
+            .filter((target) => Boolean(target && typeof target === 'object' && typeof target.id === 'string'))
+            .filter((target) => !target.type || target.type === 'page');
+    }
+    pageFromTarget(conversationId, target) {
+        return {
+            conversationId,
+            targetId: target.id,
+            url: target.url || 'about:blank',
+            webSocketDebuggerUrl: target.webSocketDebuggerUrl || null,
+            endpoint: this.cdpEndpoint(),
+        };
+    }
+    async ensureConversationPage(conversationId, startUrl = 'about:blank') {
+        const id = conversationId.trim();
+        if (!id)
+            throw new Error('conversationId is required for browser page allocation.');
+        await this.start();
+        const existing = this.conversationPages.get(id);
+        const targets = await this.listPageTargets();
+        if (existing && targets.some((target) => target.id === existing.targetId)) {
+            try {
+                await this.cdpRequest(`/json/activate/${encodeURIComponent(existing.targetId)}`);
+            }
+            catch { /* best effort */ }
+            return existing;
+        }
+        const created = await this.cdpRequest(`/json/new?${encodeURIComponent(startUrl)}`, 'PUT');
+        if (!created || typeof created.id !== 'string') {
+            throw new Error('Browser did not return a page target for the conversation.');
+        }
+        const page = this.pageFromTarget(id, created);
+        this.conversationPages.set(id, page);
+        try {
+            await this.cdpRequest(`/json/activate/${encodeURIComponent(page.targetId)}`);
+        }
+        catch { /* best effort */ }
+        return page;
+    }
+    async releaseConversationPage(conversationId) {
+        const id = conversationId.trim();
+        if (!id)
+            return { released: false, conversationId: id, targetId: null };
+        const existing = this.conversationPages.get(id);
+        this.conversationPages.delete(id);
+        if (!existing)
+            return { released: false, conversationId: id, targetId: null };
+        if (await this.probe()) {
+            try {
+                await this.cdpRequest(`/json/close/${encodeURIComponent(existing.targetId)}`);
+            }
+            catch {
+                // The user may have closed the tab or browser manually. Dropping the
+                // mapping is the important cleanup invariant.
+            }
+        }
+        return { released: true, conversationId: id, targetId: existing.targetId };
+    }
+    conversationPage(conversationId) {
+        return this.conversationPages.get(conversationId.trim()) || null;
+    }
     async waitForRunning() {
         const timeoutMs = this.opts.waitTimeoutMs ?? 15000;
         const intervalMs = this.opts.waitIntervalMs ?? 250;
@@ -263,7 +346,49 @@ class ManagedBrowser {
             channel: this.resolved?.channel || this.channel,
             userDataDir: this.userDataDir,
             executable: this.resolved?.path || null,
+            conversationPages: Array.from(this.conversationPages.values()).map((page) => ({
+                conversationId: page.conversationId,
+                targetId: page.targetId,
+            })),
         };
     }
 }
 exports.ManagedBrowser = ManagedBrowser;
+function cdpJsonRequest(endpoint, requestPath, method) {
+    return new Promise((resolve, reject) => {
+        let url;
+        try {
+            url = new URL(requestPath, endpoint);
+        }
+        catch (error) {
+            reject(error);
+            return;
+        }
+        const req = http_1.default.request(url, { method, timeout: 3000 }, (res) => {
+            let body = '';
+            res.on('data', (chunk) => { body += chunk.toString(); });
+            res.on('end', () => {
+                if ((res.statusCode || 500) >= 400) {
+                    reject(new Error(`CDP ${method} ${requestPath} failed with HTTP ${res.statusCode}`));
+                    return;
+                }
+                if (!body.trim()) {
+                    resolve({});
+                    return;
+                }
+                try {
+                    resolve(JSON.parse(body));
+                }
+                catch {
+                    resolve(body);
+                }
+            });
+        });
+        req.on('error', reject);
+        req.on('timeout', () => {
+            req.destroy();
+            reject(new Error(`CDP ${method} ${requestPath} timed out.`));
+        });
+        req.end();
+    });
+}

package/dist/src/ai-hub/native-voice-input.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WINDOWS_VOICE_INPUT_PROGRAM = exports.NativeVoiceInputError = void 0;
+exports.getVoiceInputCapability = getVoiceInputCapability;
+exports.requestWindowsVoiceInput = requestWindowsVoiceInput;
+exports.createNativeVoiceInputController = createNativeVoiceInputController;
+const node_child_process_1 = require("node:child_process");
+const node_path_1 = __importDefault(require("node:path"));
+class NativeVoiceInputError extends Error {
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = 'NativeVoiceInputError';
+    }
+}
+exports.NativeVoiceInputError = NativeVoiceInputError;
+function getVoiceInputCapability(platform = process.platform, native = false) {
+    if (platform === 'win32') {
+        return {
+            platform: 'windows', mode: native ? 'native' : 'manual', shortcutLabel: 'Win+H',
+            guidance: 'Press Win+H to start Windows Voice Typing. If it does not appear, check Windows Settings > Privacy & security > Speech and Microphone.',
+        };
+    }
+    if (platform === 'darwin') {
+        return {
+            platform: 'macos', mode: native ? 'native' : 'manual', shortcutLabel: 'Dictation shortcut',
+            guidance: 'Use the microphone key or your configured Dictation shortcut. If Dictation does not appear, enable it in System Settings > Keyboard > Dictation.',
+        };
+    }
+    return { platform: 'other', mode: 'unsupported', guidance: 'Voice input is available through system dictation on Windows and macOS.' };
+}
+// Fixed program only: no renderer or request data enters the native command.
+// The 32-byte union and individually paced events were validated in the #1844 spike.
+exports.WINDOWS_VOICE_INPUT_PROGRAM = String.raw `$ErrorActionPreference = 'Stop'
+$source = @'
+using System;
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+public static class FraimVoiceTyping {
+    [StructLayout(LayoutKind.Sequential)]
+    private struct INPUT { public uint type; public InputUnion data; }
+    [StructLayout(LayoutKind.Explicit, Size = 32)]
+    private struct InputUnion { [FieldOffset(0)] public KEYBDINPUT keyboard; }
+    [StructLayout(LayoutKind.Sequential)]
+    private struct KEYBDINPUT {
+        public ushort virtualKey; public ushort scanCode; public uint flags;
+        public uint time; public UIntPtr extraInfo;
+    }
+    [DllImport("user32.dll", SetLastError = true)]
+    private static extern uint SendInput(uint count, INPUT[] inputs, int size);
+    private static bool Emit(ushort key, uint flags) {
+        INPUT input = new INPUT { type = 1, data = new InputUnion {
+            keyboard = new KEYBDINPUT { virtualKey = key, flags = flags }
+        }};
+        return SendInput(1, new INPUT[] { input }, Marshal.SizeOf(typeof(INPUT))) == 1;
+    }
+    private static void Send(ushort key, uint flags) {
+        if (!Emit(key, flags)) throw new Win32Exception(Marshal.GetLastWin32Error());
+    }
+    public static int Invoke() {
+        bool winDown = false, hDown = false;
+        try {
+            Send(0x5B, 0); winDown = true;
+            System.Threading.Thread.Sleep(40);
+            Send(0x48, 0); hDown = true;
+            System.Threading.Thread.Sleep(40);
+            Send(0x48, 2); hDown = false;
+            System.Threading.Thread.Sleep(40);
+            Send(0x5B, 2); winDown = false;
+            return 4;
+        } finally {
+            // Release each key independently even after partial emission.
+            if (hDown) Emit(0x48, 2);
+            if (winDown) Emit(0x5B, 2);
+        }
+    }
+}
+'@
+Add-Type -TypeDefinition $source -Language CSharp
+Write-Output ([FraimVoiceTyping]::Invoke())`;
+function requestWindowsVoiceInput(execute = node_child_process_1.execFile) {
+    return new Promise((resolve, reject) => {
+        const fail = () => reject(new NativeVoiceInputError('launch_failed'));
+        try {
+            execute(node_path_1.default.win32.join(process.env.SystemRoot || 'C:\\Windows', 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe'), ['-NoProfile', '-NonInteractive', '-EncodedCommand', Buffer.from(exports.WINDOWS_VOICE_INPUT_PROGRAM, 'utf16le').toString('base64')], 
+            // execFile kills only its child on timeout and calls back after close.
+            { windowsHide: true, timeout: 5000, maxBuffer: 4096, encoding: 'utf8' }, (error, stdout) => {
+                if (error || stdout.trim() !== '4')
+                    fail();
+                else
+                    resolve();
+            });
+        }
+        catch {
+            fail();
+        }
+    });
+}
+function createNativeVoiceInputController(options) {
+    const capability = getVoiceInputCapability(options.platform ?? process.platform, true);
+    let inFlight = false;
+    return {
+        capability,
+        async start() {
+            if (capability.mode === 'unsupported')
+                throw new NativeVoiceInputError('unsupported_platform');
+            if (inFlight)
+                throw new NativeVoiceInputError('launch_failed');
+            inFlight = true;
+            try {
+                try {
+                    const win = options.getWindow();
+                    if (!win || win.isDestroyed() || win.webContents.isDestroyed())
+                        throw new Error('unavailable');
+                    win.show();
+                    win.focus();
+                    win.webContents.focus();
+                }
+                catch {
+                    throw new NativeVoiceInputError('window_unavailable');
+                }
+                try {
+                    if (capability.platform === 'windows')
+                        await (options.requestWindows ?? requestWindowsVoiceInput)();
+                    else
+                        options.sendActionToFirstResponder('startDictation:');
+                }
+                catch {
+                    throw new NativeVoiceInputError('launch_failed');
+                }
+                return { status: 'requested', capability, message: `System dictation requested. ${capability.guidance}` };
+            }
+            finally {
+                inFlight = false;
+            }
+        },
+    };
+}