fraim-framework 2.0.195 → 2.0.197

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

@@ -0,0 +1,232 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_LOGO_BYTES = exports.ORG_BRAND_FILENAME = void 0;
+exports.resolveBrandColor = resolveBrandColor;
+exports.relativeLuminance = relativeLuminance;
+exports.contrastRatio = contrastRatio;
+exports.hasSufficientContrast = hasSufficientContrast;
+exports.sanitizeSvg = sanitizeSvg;
+exports.sanitizeLogo = sanitizeLogo;
+exports.normalizeBrand = normalizeBrand;
+exports.serializeBrand = serializeBrand;
+exports.parseBrand = parseBrand;
+exports.readBrandFromDir = readBrandFromDir;
+exports.writeBrandToDir = writeBrandToDir;
+/**
+ * Org brand store — Issue #744 (Hub cobranding).
+ *
+ * Deterministic, dependency-free, AI-free logic (architecture-standards §1/§3):
+ * the org brand descriptor (company name, color, logo) is stored ALONGSIDE
+ * company info, in the same org context storage as `org_context.md`
+ * (manager directive, spec R7.4), as a single `org_brand.json` file.
+ *
+ * Security: a manager-supplied logo is a stored-XSS vector. `sanitizeSvg` uses a
+ * strict element/attribute allowlist (not a denylist) and drops scripts, event
+ * handlers, external references, styles, and any non-graphical element, so the
+ * stored logo is safe to inline in the Hub (spec Compliance: SOC2/ISO27001).
+ */
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+/** File name of the brand descriptor, stored next to org_context.md. */
+exports.ORG_BRAND_FILENAME = 'org_brand.json';
+/** Max stored logo size (sanitized SVG markup or data: URI), in bytes. */
+exports.MAX_LOGO_BYTES = 512 * 1024;
+// ── Color ───────────────────────────────────────────────────────────────────
+/**
+ * Normalize a hex color to lowercase `#rrggbb`, expanding `#rgb`. Returns null
+ * for anything that is not a valid 3- or 6-digit hex (named colors, functions,
+ * and injection attempts are rejected).
+ */
+function resolveBrandColor(input) {
+    if (typeof input !== 'string')
+        return null;
+    const raw = input.trim().replace(/^#/, '').toLowerCase();
+    if (/^[0-9a-f]{3}$/.test(raw)) {
+        return '#' + raw.split('').map((c) => c + c).join('');
+    }
+    if (/^[0-9a-f]{6}$/.test(raw)) {
+        return '#' + raw;
+    }
+    return null;
+}
+function hexToRgb(hex) {
+    const norm = resolveBrandColor(hex);
+    if (!norm)
+        return null;
+    const n = norm.slice(1);
+    return [parseInt(n.slice(0, 2), 16), parseInt(n.slice(2, 4), 16), parseInt(n.slice(4, 6), 16)];
+}
+/** WCAG relative luminance of an sRGB color. */
+function relativeLuminance(hex) {
+    const rgb = hexToRgb(hex);
+    if (!rgb)
+        return 0;
+    const [r, g, b] = rgb.map((v) => {
+        const s = v / 255;
+        return s <= 0.03928 ? s / 12.92 : Math.pow((s + 0.055) / 1.055, 2.4);
+    });
+    return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+/** WCAG contrast ratio between two colors (1..21). */
+function contrastRatio(a, b) {
+    const la = relativeLuminance(a);
+    const lb = relativeLuminance(b);
+    const lighter = Math.max(la, lb);
+    const darker = Math.min(la, lb);
+    return (lighter + 0.05) / (darker + 0.05);
+}
+/**
+ * True when `color` is readable as a UI accent against `background`. Uses the
+ * WCAG 3:1 threshold for graphical/large UI objects (the accent is used on
+ * filled buttons and tab underlines, not as body text). Guards R2.3 so an
+ * unreadable brand color never ships; callers fall back to the FRAIM accent.
+ */
+function hasSufficientContrast(color, background, min = 3.0) {
+    if (!resolveBrandColor(color) || !resolveBrandColor(background))
+        return false;
+    return contrastRatio(color, background) >= min;
+}
+// ── SVG sanitization (allowlist) ──────────────────────────────────────────────
+/** Only these elements survive sanitization. */
+const ALLOWED_SVG_TAGS = new Set([
+    'svg', 'g', 'path', 'rect', 'circle', 'ellipse', 'line', 'polyline', 'polygon',
+    'text', 'tspan', 'defs', 'lineargradient', 'radialgradient', 'stop', 'title', 'desc',
+]);
+/** Only these attributes survive; everything else (incl. on*, href, style) is dropped. */
+const ALLOWED_SVG_ATTRS = new Set([
+    'viewbox', 'xmlns', 'width', 'height', 'fill', 'fill-rule', 'fill-opacity', 'stroke',
+    'stroke-width', 'stroke-linecap', 'stroke-linejoin', 'stroke-dasharray', 'stroke-opacity',
+    'opacity', 'd', 'points', 'x', 'y', 'x1', 'y1', 'x2', 'y2', 'cx', 'cy', 'r', 'rx', 'ry',
+    'transform', 'offset', 'stop-color', 'stop-opacity', 'gradientunits', 'gradienttransform',
+    'font-family', 'font-size', 'font-weight', 'text-anchor', 'letter-spacing',
+]);
+/**
+ * Sanitize an SVG string via a strict allowlist. Returns safe SVG markup, or ''
+ * if the input is not an <svg> document. Removes: <script>, <foreignObject>,
+ * <image>, <use>, <a>, comments/PIs/DOCTYPE, all event handlers, all href /
+ * xlink:href, inline styles, and any element or attribute not on the allowlist.
+ */
+function sanitizeSvg(input) {
+    if (typeof input !== 'string')
+        return '';
+    // Bound the work up front so a pathological logo can't drive the tag-walk
+    // regex into catastrophic backtracking (DoS guard).
+    if (input.length > exports.MAX_LOGO_BYTES)
+        return '';
+    let s = input.trim();
+    if (!/^<svg[\s>]/i.test(s))
+        return '';
+    // Drop comments, CDATA, processing instructions, and DOCTYPE outright.
+    s = s.replace(/<!--[\s\S]*?-->/g, '');
+    s = s.replace(/<!\[CDATA\[[\s\S]*?\]\]>/g, '');
+    s = s.replace(/<\?[\s\S]*?\?>/g, '');
+    s = s.replace(/<!DOCTYPE[\s\S]*?>/gi, '');
+    // Drop dangerous elements and their entire content.
+    s = s.replace(/<(script|style|foreignObject|iframe|use|image|a)\b[\s\S]*?<\/\1\s*>/gi, '');
+    // Drop self-closing / unclosed variants of the same dangerous elements.
+    s = s.replace(/<(script|style|foreignObject|iframe|use|image|a)\b[^>]*\/?>/gi, '');
+    // Walk every remaining tag; drop non-allowlisted elements and attributes.
+    s = s.replace(/<\/?([a-zA-Z][\w:-]*)((?:[^>"']|"[^"]*"|'[^']*')*)>/g, (full, rawName, rawAttrs) => {
+        const name = rawName.toLowerCase().replace(/^svg:/, '');
+        if (!ALLOWED_SVG_TAGS.has(name))
+            return '';
+        const isClose = /^<\//.test(full);
+        if (isClose)
+            return `</${name}>`;
+        const selfClose = /\/>$/.test(full);
+        const attrs = [];
+        const attrRe = /([a-zA-Z_:][\w:.-]*)\s*=\s*("([^"]*)"|'([^']*)')/g;
+        let m;
+        while ((m = attrRe.exec(rawAttrs)) !== null) {
+            const attr = m[1].toLowerCase().replace(/^xml:/, '');
+            const value = m[3] !== undefined ? m[3] : m[4] || '';
+            if (!ALLOWED_SVG_ATTRS.has(attr))
+                continue;
+            // Defense in depth: never allow url()/javascript:/data: sneaking through a value.
+            if (/javascript:|url\s*\(|data:|expression\s*\(|<|>/i.test(value))
+                continue;
+            attrs.push(`${attr}="${value.replace(/"/g, '&quot;')}"`);
+        }
+        const attrStr = attrs.length ? ' ' + attrs.join(' ') : '';
+        return `<${name}${attrStr}${selfClose ? '/' : ''}>`;
+    });
+    // If sanitization emptied the root, treat as invalid.
+    if (!/^<svg[\s>]/i.test(s.trim()))
+        return '';
+    return s.trim();
+}
+/** Accept only png/jpeg data URIs (sanitized SVG is handled separately). */
+function isSafeRasterDataUri(s) {
+    return /^data:image\/(png|jpe?g);base64,[a-z0-9+/=\s]+$/i.test(s);
+}
+/** Sanitize a logo value: SVG markup -> sanitized SVG; png/jpeg data URI -> kept; else ''. */
+function sanitizeLogo(input) {
+    if (typeof input !== 'string' || !input.trim())
+        return '';
+    const s = input.trim();
+    if (/^<svg[\s>]/i.test(s)) {
+        const clean = sanitizeSvg(s);
+        return clean.length <= exports.MAX_LOGO_BYTES ? clean : '';
+    }
+    if (isSafeRasterDataUri(s)) {
+        return s.length <= exports.MAX_LOGO_BYTES ? s : '';
+    }
+    return '';
+}
+// ── Serialize / parse ─────────────────────────────────────────────────────────
+/** Normalize + sanitize a brand into its safe stored form. */
+function normalizeBrand(brand) {
+    const out = {};
+    if (typeof brand.name === 'string' && brand.name.trim()) {
+        out.name = brand.name.trim().slice(0, 120);
+    }
+    const color = resolveBrandColor(brand.color);
+    if (color)
+        out.color = color;
+    const logo = sanitizeLogo(brand.logo);
+    if (logo)
+        out.logo = logo;
+    return out;
+}
+function serializeBrand(brand) {
+    return JSON.stringify(normalizeBrand(brand), null, 2);
+}
+/** Parse a brand JSON string into a normalized OrgBrand, or null on any error. */
+function parseBrand(json) {
+    if (typeof json !== 'string' || !json.trim())
+        return null;
+    let obj;
+    try {
+        obj = JSON.parse(json);
+    }
+    catch {
+        return null;
+    }
+    if (!obj || typeof obj !== 'object')
+        return null;
+    const norm = normalizeBrand(obj);
+    return Object.keys(norm).length ? norm : null;
+}
+// ── Directory read / write ─────────────────────────────────────────────────────
+/** Read + normalize the brand from `<dir>/org_brand.json`, or null when absent/invalid. */
+function readBrandFromDir(dir) {
+    try {
+        const file = path_1.default.join(dir, exports.ORG_BRAND_FILENAME);
+        if (!fs_1.default.existsSync(file))
+            return null;
+        return parseBrand(fs_1.default.readFileSync(file, 'utf8'));
+    }
+    catch {
+        return null;
+    }
+}
+/** Sanitize + normalize a brand and write it to `<dir>/org_brand.json`. Returns the stored brand. */
+function writeBrandToDir(dir, brand) {
+    const normalized = normalizeBrand(brand);
+    fs_1.default.mkdirSync(dir, { recursive: true });
+    fs_1.default.writeFileSync(path_1.default.join(dir, exports.ORG_BRAND_FILENAME), JSON.stringify(normalized, null, 2), 'utf8');
+    return normalized;
+}

package/dist/src/ai-hub/server.js

@@ -49,6 +49,7 @@ const child_process_1 = require("child_process");
 const https_1 = __importDefault(require("https"));
 const types_1 = require("../first-run/types");
 const learning_context_builder_1 = require("../local-mcp-server/learning-context-builder");
+const brand_store_1 = require("./brand-store");
 const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
 const catalog_1 = require("./catalog");
 const agent_token_prices_1 = require("../local-mcp-server/agent-token-prices");
@@ -1447,6 +1448,9 @@ class AiHubServer {
             // #533: the resolved account email, so the profile card shows the real
             // identity (not a hardcoded placeholder) and the client can display it.
             userEmail: getHubUserEmail(),
+            // #744: the org cobrand identity (name/color/logo) from the org context
+            // storage, or null when unset so the Hub falls back to FRAIM identity.
+            orgBrand: (0, learning_context_builder_1.readOrgBrand)(normalizedProjectPath),
             assignments: { byProject: {}, source: 'client-localStorage' },
             // Issue #538 — source of truth for the "Hire a human manager" UI. Lazy-required
             // (not a top-level import) so the lightweight client CLI paths that import this
@@ -1971,59 +1975,41 @@ class AiHubServer {
         }));
         try {
             // Issue #701: persona state comes from the hosted server (GET /api/personas/me)
-            // via the user's API key — never a local MongoDB connection. A null result means
-            // no/expired key or the feature is off; render the locked fallback (not-signed-in).
+            // via the user's API key — never a local MongoDB connection.
             const state = await this.remoteGateway.getPersonaState(apiKey);
+            // A null result means we could not reach the authority (no/expired key or a
+            // transport error). That is the ONLY access decision the Hub makes on its own —
+            // render the locked "not-signed-in" fallback. When a state IS returned, its
+            // per-persona `status` is authoritative and rendered verbatim: the hired/locked
+            // decision (feature-off, legacy bypass, per-entitlement gating) lives solely in
+            // persona-entitlement-service.resolvePersonaAccessStatuses — the Hub does not
+            // re-derive it.
             if (!state) {
                 return { personas: fallbackPersonas, subscriptionActive: false, workspaceId: null, userKey: null };
             }
-            // Legacy bypass: persona gating is not active for this workspace, so all personas are accessible.
-            // Mirrors the evaluatePersonaAccess legacy bypass in persona-entitlement-service.ts.
-            // Seats are not assignable on legacy workspaces (the hosted server is always DB-backed).
-            if (!state.subscriptionActive) {
-                const allPersonas = allBundles.map((bundle) => ({
-                    key: bundle.personaKey,
-                    displayName: bundle.catalogMetadata.displayName,
-                    role: bundle.catalogMetadata.role,
-                    avatarUrl: buildHubPersonaAvatarUrl(bundle.personaKey),
-                    pricingLabel: '',
-                    status: 'hired',
-                    hireUrl: buildHubPersonaHireUrl(bundle.personaKey, bundle.defaultHireMode),
-                    seatCount: 0,
-                    seatsInUse: 0,
-                }));
-                return { personas: allPersonas, subscriptionActive: false, workspaceId: state.workspaceId, userKey: state.userId ?? null };
-            }
-            const hiredKeys = new Set(state.entitlements
-                .filter((e) => e.status === 'active')
-                .map((e) => e.personaKey));
-            // Build per-persona seat counts from entitlement records.
-            // jobCreditsRemaining represents the number of job-credits (seats) purchased.
-            const seatCountByKey = {};
-            for (const e of state.entitlements) {
-                if (e.status === 'active') {
-                    seatCountByKey[e.personaKey] = (seatCountByKey[e.personaKey] ?? 0) + (e.jobCreditsRemaining ?? 1);
-                }
-            }
-            // seatsInUse for display: derived from the hosted manager team. Authoritative
-            // out-of-stock enforcement lives on the hosted assign endpoint (server-side),
-            // so this display count does not need to be workspace-wide.
+            const verdictByKey = new Map((state.personas || []).map((p) => [p.personaKey, p]));
+            // seatsInUse (manager-team assignments) is display-only accounting fetched
+            // separately; it is not part of the access verdict.
             const seatsInUseByKey = {};
             const team = await this.remoteGateway.listManagerTeam(apiKey);
             for (const entry of team) {
                 seatsInUseByKey[entry.personaKey] = (seatsInUseByKey[entry.personaKey] ?? 0) + 1;
             }
-            const personas = allBundles.map((bundle) => ({
-                key: bundle.personaKey,
-                displayName: bundle.catalogMetadata.displayName,
-                role: bundle.catalogMetadata.role,
-                avatarUrl: buildHubPersonaAvatarUrl(bundle.personaKey),
-                pricingLabel: hiredKeys.has(bundle.personaKey) ? '' : bundle.catalogMetadata.pricingLabel,
-                status: (hiredKeys.has(bundle.personaKey) ? 'hired' : 'locked'),
-                hireUrl: buildHubPersonaHireUrl(bundle.personaKey, bundle.defaultHireMode),
-                seatCount: seatCountByKey[bundle.personaKey] ?? 0,
-                seatsInUse: seatsInUseByKey[bundle.personaKey] ?? 0,
-            }));
+            const personas = allBundles.map((bundle) => {
+                const verdict = verdictByKey.get(bundle.personaKey);
+                const status = (verdict?.status ?? 'locked');
+                return {
+                    key: bundle.personaKey,
+                    displayName: bundle.catalogMetadata.displayName,
+                    role: bundle.catalogMetadata.role,
+                    avatarUrl: buildHubPersonaAvatarUrl(bundle.personaKey),
+                    pricingLabel: status === 'hired' ? '' : bundle.catalogMetadata.pricingLabel,
+                    status,
+                    hireUrl: buildHubPersonaHireUrl(bundle.personaKey, bundle.defaultHireMode),
+                    seatCount: verdict?.seatCount ?? 0,
+                    seatsInUse: seatsInUseByKey[bundle.personaKey] ?? 0,
+                };
+            });
             return { personas, subscriptionActive: state.subscriptionActive, workspaceId: state.workspaceId, userKey: state.userId ?? null };
         }
         catch (err) {
@@ -2320,7 +2306,15 @@ class AiHubServer {
                 ? path_1.default.resolve(req.query.projectPath)
                 : this.projectPath;
             const known = this.knownProjects(projectPath);
-            const entry = known.find((project) => project.id === req.params.id);
+            // Match by id, falling back to the canonical folderPath. The client and server
+            // hash a path to an id with different algorithms, and the client mints its own id
+            // for the CURRENT project (tfEnsureCurrentProject), so a delete-by-id can carry an
+            // id the server never assigned — the folderPath is the true project identity (#726).
+            const requestedFolderPath = typeof req.query.folderPath === 'string' && req.query.folderPath.length > 0
+                ? req.query.folderPath
+                : null;
+            const entry = known.find((project) => project.id === req.params.id)
+                || (requestedFolderPath ? known.find((project) => sameDirectoryPath(project.folderPath, requestedFolderPath)) : undefined);
             if (!entry)
                 return res.status(404).json({ error: 'Project not found.' });
             // The current projectPath is unconditionally re-injected on every load, so
@@ -2461,6 +2455,45 @@ class AiHubServer {
             // Re-read so the client gets the canonical post-write state (present flips).
             return res.json(readContextFile(projectPath, body.key));
         });
+        // Issue #744 — Hub cobranding.
+        // GET  /api/ai-hub/brand  → { brand: OrgBrand | null } resolved from the org
+        //   context storage (same layering as org_context.md).
+        // POST /api/ai-hub/brand  { name?, color?, logo?, projectPath? }  → sanitizes
+        //   + normalizes (SVG allowlist, hex normalize) and persists org_brand.json to
+        //   the org context write location. Loopback-only; write is constrained under
+        //   a personalized-employee/ directory (same path-traversal guard as context).
+        this.app.get('/api/ai-hub/brand', (req, res) => {
+            const projectPath = typeof req.query.projectPath === 'string' && req.query.projectPath.length > 0
+                ? path_1.default.resolve(req.query.projectPath)
+                : this.projectPath;
+            return res.json({ brand: (0, learning_context_builder_1.readOrgBrand)(projectPath) });
+        });
+        this.app.post('/api/ai-hub/brand', (req, res) => {
+            const body = (req.body ?? {});
+            const projectPath = typeof body.projectPath === 'string' && body.projectPath.length > 0
+                ? path_1.default.resolve(body.projectPath)
+                : this.projectPath;
+            const input = {
+                name: typeof body.name === 'string' ? body.name : undefined,
+                color: typeof body.color === 'string' ? body.color : undefined,
+                logo: typeof body.logo === 'string' ? body.logo : undefined,
+            };
+            const dest = path_1.default.resolve((0, learning_context_builder_1.resolveOrgBrandWriteDir)(projectPath));
+            // Path-traversal guard: the write dir must live under a personalized-employee
+            // directory (matches the context write guard; never the managed org cache).
+            if (!dest.split(path_1.default.sep).includes('personalized-employee')) {
+                return res.status(403).json({ error: 'Brand write destination outside personalized-employee.' });
+            }
+            try {
+                // writeBrandToDir sanitizes the logo (SVG allowlist) and normalizes the
+                // color before persisting, so unsafe input never reaches disk.
+                const stored = (0, brand_store_1.writeBrandToDir)(dest, input);
+                return res.json({ brand: stored });
+            }
+            catch (err) {
+                return res.status(500).json({ error: err instanceof Error ? err.message : 'Brand write failed.' });
+            }
+        });
         this.app.post('/api/ai-hub/artifact/open', async (req, res) => {
             const rawPath = typeof req.body?.path === 'string' ? req.body.path : '';
             const projectPath = typeof req.body?.projectPath === 'string' && req.body.projectPath.length > 0

package/dist/src/api/personas/me.js

@@ -10,13 +10,13 @@ async function getMyPersonas(req, res, dbService) {
             res.status(401).json({ error: 'Authentication required' });
             return;
         }
+        // Feature OFF => the persona system isn't gating anything, so report the
+        // ungated state (every persona accessible) rather than a 404. This makes the
+        // authenticated persona view a single source of truth the Hub renders
+        // verbatim, and matches the execution gate (maybeBuildPersonaLockResponse),
+        // which also treats "flag off" as "allowed". No DB lookup needed.
         if (!(0, feature_flags_1.isPersonaEntitlementsEnabled)()) {
-            res.status(404).json({
-                error: 'Not found',
-                featureFlags: {
-                    personaEntitlements: false
-                }
-            });
+            res.json((0, persona_entitlement_service_1.buildUngatedPersonaWorkspaceState)(apiKeyData.userId, apiKeyData.key));
             return;
         }
         const state = await (0, persona_entitlement_service_1.getWorkspacePersonaState)(dbService, apiKeyData.userId, apiKeyData.key);

package/dist/src/cli/utils/org-pack-sync.js

@@ -4,6 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ORG_CACHE_MANAGED_HEADER = exports.ORG_SYNC_METADATA_FILE = exports.ORG_CACHE_DIRNAME = void 0;
+exports.isSafePackPath = isSafePackPath;
+exports.shouldDecorateAsMarkdown = shouldDecorateAsMarkdown;
 exports.getOrgCacheDir = getOrgCacheDir;
 exports.readOrgCacheMetadata = readOrgCacheMetadata;
 exports.getOrgCacheAgeHours = getOrgCacheAgeHours;
@@ -37,6 +39,28 @@ const ORG_PACK_DIRS = ['context', 'rules', 'learnings'];
  * backend response can never write outside the cache directory.
  */
 const SAFE_PACK_RELATIVE_PATH = /^(context|rules|learnings)\/[\w.-]+\.md$/;
+/**
+ * Issue #744: the org brand descriptor is stored ALONGSIDE company info, in the
+ * same org context scope as org_context.md, as a single JSON file. Allow exactly
+ * that path (not arbitrary JSON) so cobranding syncs like org context.
+ */
+const ORG_BRAND_PACK_PATH = 'context/org_brand.json';
+/**
+ * True when a pack-relative path is safe to materialize: a markdown file inside
+ * one of the three org pack dirs, or the org brand descriptor. A single guard
+ * shared by the git and cloud paths.
+ */
+function isSafePackPath(relativePath) {
+    return SAFE_PACK_RELATIVE_PATH.test(relativePath) || relativePath === ORG_BRAND_PACK_PATH;
+}
+/**
+ * Managed-content decoration prepends a markdown "synced from your org" header.
+ * It must only touch markdown — prepending it to org_brand.json would corrupt
+ * the JSON (#744).
+ */
+function shouldDecorateAsMarkdown(relativePath) {
+    return relativePath.toLowerCase().endsWith('.md');
+}
 function getOrgCacheDir() {
     return path_1.default.join((0, project_fraim_paths_1.getUserFraimDirPath)(), exports.ORG_CACHE_DIRNAME);
 }
@@ -83,10 +107,12 @@ function collectGitPackFiles(snapshotDir) {
         if (!fs_1.default.existsSync(dirPath))
             continue;
         for (const entry of fs_1.default.readdirSync(dirPath, { withFileTypes: true })) {
-            if (!entry.isFile() || !entry.name.endsWith('.md'))
+            const relativePath = `${dirName}/${entry.name}`;
+            // Markdown in any pack dir, plus the org brand descriptor (#744).
+            if (!entry.isFile() || !isSafePackPath(relativePath))
                 continue;
             files.push({
-                relativePath: `${dirName}/${entry.name}`,
+                relativePath,
                 content: fs_1.default.readFileSync(path_1.default.join(dirPath, entry.name), 'utf8')
             });
         }
@@ -101,7 +127,7 @@ async function fetchCloudPack(remoteUrl, apiKey) {
     const files = Array.isArray(response.data?.files) ? response.data.files : [];
     return {
         files: files.filter((f) => typeof f?.relativePath === 'string' &&
-            SAFE_PACK_RELATIVE_PATH.test(f.relativePath) &&
+            isSafePackPath(f.relativePath) &&
             typeof f?.content === 'string'),
         version: String(response.data?.version ?? '0')
     };
@@ -113,11 +139,15 @@ function materializeCache(files, metadata) {
     fs_1.default.rmSync(stagingDir, { recursive: true, force: true });
     fs_1.default.mkdirSync(stagingDir, { recursive: true });
     for (const file of files) {
-        if (!SAFE_PACK_RELATIVE_PATH.test(file.relativePath))
+        if (!isSafePackPath(file.relativePath))
             continue;
         const destination = path_1.default.join(stagingDir, file.relativePath);
         fs_1.default.mkdirSync(path_1.default.dirname(destination), { recursive: true });
-        fs_1.default.writeFileSync(destination, decorateManagedOrgFile(file.content, metadata.backend));
+        // #744: only markdown gets the managed-content header; JSON is written verbatim.
+        const content = shouldDecorateAsMarkdown(file.relativePath)
+            ? decorateManagedOrgFile(file.content, metadata.backend)
+            : file.content;
+        fs_1.default.writeFileSync(destination, content);
     }
     fs_1.default.writeFileSync(path_1.default.join(stagingDir, exports.ORG_SYNC_METADATA_FILE), JSON.stringify(metadata, null, 2));
     fs_1.default.rmSync(cacheDir, { recursive: true, force: true });

package/dist/src/first-run/types.js

@@ -52,7 +52,7 @@ exports.FIRST_RUN_AGENT_OPTIONS = [
     },
     {
         id: 'copilot-cli',
-        label: 'GitHub Copilot',
+        label: 'GitHub Copilot CLI',
         detectAliases: ['copilot', 'copilot-cli', 'github copilot cli'],
         loginCommand: 'copilot login',
         launchCommand: 'copilot',

package/dist/src/local-mcp-server/learning-context-builder.js

@@ -14,6 +14,8 @@ exports.buildTeamContextSection = buildTeamContextSection;
 exports.resolveTeamContextFiles = resolveTeamContextFiles;
 exports.isTeamContextKey = isTeamContextKey;
 exports.resolveTeamContextFile = resolveTeamContextFile;
+exports.readOrgBrand = readOrgBrand;
+exports.resolveOrgBrandWriteDir = resolveOrgBrandWriteDir;
 exports.countPreservedLearnings = countPreservedLearnings;
 exports.readPreservedLearnings = readPreservedLearnings;
 exports.applyLearningEntryChange = applyLearningEntryChange;
@@ -21,6 +23,7 @@ exports.isTruthyFlag = isTruthyFlag;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const project_fraim_paths_1 = require("../core/utils/project-fraim-paths");
+const brand_store_1 = require("../ai-hub/brand-store");
 const REPO_LEARNINGS_REL = (0, project_fraim_paths_1.getWorkspaceFraimDisplayPath)('personalized-employee/learnings').replace(/\/$/, '');
 const DEFAULT_THRESHOLD = 3.0;
 const AGING_HORIZON_DAYS = 7;
@@ -695,6 +698,44 @@ function resolveTeamContextFile(workspaceRoot, key) {
         scope
     };
 }
+// ---------------------------------------------------------------------------
+// Issue #744 — Org brand (Hub cobranding).
+//
+// The brand descriptor (company name/logo/color) is stored ALONGSIDE company
+// info, in the SAME org context storage as org_context.md (manager directive,
+// spec R7.4), as `context/org_brand.json`. Read resolves with the same org-scope
+// layering as org context (repo-local override → synced org cache → user-level);
+// writes target the same writable location org context edits use.
+// ---------------------------------------------------------------------------
+/** Ordered directories to look for org_brand.json, mirroring org-context layering. */
+function orgBrandCandidateDirs(workspaceRoot) {
+    return [
+        (0, path_1.join)((0, project_fraim_paths_1.getWorkspaceFraimDir)(workspaceRoot), 'personalized-employee', 'context'),
+        (0, path_1.join)((0, project_fraim_paths_1.getUserFraimDirPath)(), 'org', 'context'),
+        (0, path_1.join)((0, project_fraim_paths_1.getUserFraimDirPath)(), 'personalized-employee', 'context'),
+    ];
+}
+/** Read the resolved org brand, or null when none is set on this machine. */
+function readOrgBrand(workspaceRoot) {
+    for (const dir of orgBrandCandidateDirs(workspaceRoot)) {
+        const brand = (0, brand_store_1.readBrandFromDir)(dir);
+        if (brand)
+            return brand;
+    }
+    return null;
+}
+/**
+ * Directory an org-brand edit should be written to. Mirrors org-context write
+ * resolution: the repo-local override dir when the repo carries its own org
+ * context, otherwise the portable user-level context dir (where org onboarding
+ * writes). Never the synced org cache (managed, overwritten on sync).
+ */
+function resolveOrgBrandWriteDir(workspaceRoot) {
+    const loc = resolveTeamContextFile(workspaceRoot, 'org');
+    if (loc.writePath)
+        return (0, path_1.dirname)(loc.writePath);
+    return (0, path_1.join)((0, project_fraim_paths_1.getUserFraimDirPath)(), 'personalized-employee', 'context');
+}
 /**
  * Count the number of `## [P-...]`-style entries inside a preserved learning
  * file. Returns 0 when the file is absent or unreadable. Counts ALL entries