@phuetz/code-buddy 2.0.0 → 2.1.0

package/dist/server/types.d.ts

@@ -133,6 +133,10 @@ export interface JwtPayload {
     type?: 'api_key' | 'user';
     /** Optional operator role stamped by `buddy token --role`. */
     role?: 'user' | 'admin';
+    /** Android device proof claims; absent on legacy tokens. */
+    amr?: string[];
+    profile?: 'agent' | 'companion';
+    identity?: 'owner';
 }
 export interface AuthenticatedRequest {
     auth: {

package/dist/server/websocket/handler.d.ts

@@ -26,6 +26,13 @@ interface ConnectionState {
     keyId?: string;
     /** Paired device id when authenticated via the device-pairing flow. */
     deviceId?: string;
+    /** Signed Android identity, available to companion extensions. */
+    profile?: 'agent' | 'companion';
+    identity?: 'owner';
+    amr?: readonly string[];
+    deviceAuthExpiresAt?: number;
+    /** Server configuration secret, used only for the new device token path. */
+    deviceJwtSecret?: string;
     scopes: string[];
     /** No-auth network clients remain transport-visible but cannot run agent chat. */
     anonymousRemote?: boolean;
@@ -77,6 +84,9 @@ export interface WebSocketExtensionPrincipal {
     /** Server-derived principal id; request payloads cannot override it. */
     readonly id: string;
     readonly source: string;
+    readonly profile?: 'agent' | 'companion';
+    readonly identity?: 'owner';
+    readonly amr?: readonly string[];
     readonly scopes: readonly string[];
     readonly loopback: boolean;
     readonly secure: boolean;
@@ -179,6 +189,7 @@ export declare function produceCompanionReply(message: string, options?: {
     history?: CompanionHistoryTurn[];
     /** Photos the phone attached — already validated by `validateChatAttachments`. */
     attachments?: ValidatedChatAttachment[];
+    userId?: string;
 }): Promise<string | {
     text: string;
     image?: {
@@ -186,6 +197,8 @@ export declare function produceCompanionReply(message: string, options?: {
         data: string;
     };
     kind?: 'selfie' | 'text';
+    imagePath?: string;
+    historySuffix?: string;
 }>;
 /**
  * Setup WebSocket server

package/dist/server/websocket/handler.js

@@ -7,6 +7,10 @@ import { validateApiKey } from '../auth/api-keys.js';
 import { logger } from "../../utils/logger.js";
 import { isOriginAllowed } from '../origin-check.js';
 import { verifyToken } from '../auth/jwt.js';
+import { getDeviceAuthStore } from '../auth/device-store.js';
+import { withDeviceSessionIdentity } from '../auth/device-session-context.js';
+import { getPermissionModeManager } from '../../security/permission-modes.js';
+import { ConfirmationService } from '../../utils/confirmation-service.js';
 import { isDirectLoopbackRequest } from '../middleware/auth.js';
 import { authenticateDevice, getGatewayPairingStore, isDevicePairingRequired } from '../../gateway/device-pairing.js';
 import { gatewayServerVersion, GATEWAY_PROTOCOL_VERSION } from '../../gateway/protocol.js';
@@ -84,6 +88,7 @@ function extensionPrincipal(state) {
     return Object.freeze({
         id,
         source,
+        ...sessionIdentityClaims(state),
         scopes: Object.freeze(state.authenticated ? [...state.scopes] : []),
         loopback: state.loopback === true,
         secure: state.secure === true,
@@ -138,7 +143,16 @@ function cleanupWebSocketExtensions(state) {
     }
     listeners.clear();
 }
-function resetWebSocketExtensionsForIdentityChange(state) {
+function resetWebSocketExtensionsForIdentityChange(state, deviceIdentity = false) {
+    if (deviceIdentity || state.profile !== undefined) {
+        state.agent?.dispose?.();
+        state.agent = undefined;
+        state.agentInitializing = undefined;
+    }
+    state.profile = undefined;
+    state.identity = undefined;
+    state.amr = undefined;
+    state.deviceAuthExpiresAt = undefined;
     state.approvalCapable = false;
     cleanupWebSocketExtensions(state);
     state.extensionsCleaned = false;
@@ -146,6 +160,17 @@ function resetWebSocketExtensionsForIdentityChange(state) {
     // companion conversation.
     state.companionHistory = undefined;
 }
+/** Conditional spreads preserve the exact legacy principal and auth payload. */
+function sessionIdentityClaims(state) {
+    return {
+        ...(state.profile ? { profile: state.profile } : {}),
+        ...(state.identity ? { identity: state.identity } : {}),
+        ...(state.amr ? { amr: state.amr } : {}),
+    };
+}
+function deviceSessionIsActive(state) {
+    return state.deviceAuthExpiresAt === undefined || (state.deviceAuthExpiresAt > Date.now() && !!state.deviceId && getDeviceAuthStore().isActive(state.deviceId));
+}
 /**
  * Add a message type without leaking the underlying socket or ConnectionState.
  * The returned function removes exactly this registration and is idempotent.
@@ -432,24 +457,40 @@ messageHandlers.set('authenticate', async (ws, state, payload) => {
     if (token) {
         // JWT_SECRET is required - if not set, authentication will fail (secure by default)
         const jwtSecret = process.env.JWT_SECRET;
-        if (!jwtSecret) {
+        const configuredToken = state.deviceJwtSecret ? verifyToken(token, state.deviceJwtSecret) : null;
+        const deviceToken = Array.isArray(configuredToken?.amr) && configuredToken.amr.includes('device') ? configuredToken : null;
+        if (!jwtSecret && !deviceToken) {
             sendError(ws, 'CONFIG_ERROR', 'Server JWT configuration missing');
             return;
         }
-        const decoded = verifyToken(token, jwtSecret);
+        const decoded = deviceToken ?? verifyToken(token, jwtSecret);
         if (decoded) {
-            resetWebSocketExtensionsForIdentityChange(state);
+            const isDevice = Array.isArray(decoded.amr) && decoded.amr.includes('device');
+            if (isDevice && (!Number.isFinite(decoded.exp) || decoded.exp * 1000 <= Date.now() || !getDeviceAuthStore().isActive(decoded.sub))) {
+                sendError(ws, 'AUTH_FAILED', 'Invalid credentials');
+                return;
+            }
+            resetWebSocketExtensionsForIdentityChange(state, decoded.profile !== undefined);
             state.authenticated = true;
             state.userId = decoded.userId ?? decoded.sub;
             state.keyId = undefined;
-            state.deviceId = undefined;
+            state.deviceId = isDevice ? decoded.sub : undefined;
+            state.deviceAuthExpiresAt = isDevice ? decoded.exp * 1000 : undefined;
+            state.profile = decoded.profile === 'agent' || decoded.profile === 'companion' ? decoded.profile : undefined;
+            state.identity = decoded.identity === 'owner' ? 'owner' : undefined;
+            state.amr = Array.isArray(decoded.amr) ? Object.freeze(decoded.amr.filter((method) => typeof method === 'string')) : undefined;
             state.scopes = decoded.scopes || ['chat'];
             state.anonymousRemote = false;
             if (approvalCapable === true)
                 state.approvalCapable = true;
+            if (state.profile === 'agent') {
+                // Native Android is an approval surface even when the PWA is disabled.
+                state.approvalCapable = true;
+                wireMobileConfirmationBridge({ broadcast, collectApprovalSurfaceIds, registerExtension: registerWebSocketExtension });
+            }
             send(ws, {
                 type: 'authenticated',
-                payload: { userId: state.userId, scopes: state.scopes },
+                payload: { userId: state.userId, scopes: state.scopes, ...sessionIdentityClaims(state) },
                 timestamp: new Date().toISOString(),
             });
             return;
@@ -507,17 +548,22 @@ export async function produceCompanionReply(message, options = {}) {
     const result = await runCompanionTurn(message, {
         surface: 'mobile',
         includeImageBytes: true,
+        ...(options.userId ? { userId: options.userId } : {}),
         ...(options.history ? { history: options.history } : {}),
         ...(options.attachments?.length ? { attachments: options.attachments } : {}),
     });
-    if (result.image || result.kind === 'selfie') {
+    if (result.image || result.kind === 'selfie' || result.imagePath) {
         return {
             text: result.text,
             ...(result.image ? { image: result.image } : {}),
             kind: result.kind,
+            ...(result.imagePath ? { imagePath: result.imagePath } : {}),
+            ...(result.historySuffix ? { historySuffix: result.historySuffix } : {}),
         };
     }
-    return result.text;
+    return result.historySuffix
+        ? { text: result.text, kind: 'text', historySuffix: result.historySuffix }
+        : result.text;
 }
 /** Persistence identity for this connection, or undefined (memory-only). */
 function companionHistoryIdentity(state) {
@@ -535,7 +581,9 @@ function companionHistoryFor(state) {
 }
 /** Record one companion exchange; never stores image bytes. */
 function rememberCompanionTurn(state, userText, produced) {
-    const assistantText = typeof produced === 'string' ? produced : produced.text;
+    const baseAssistantText = typeof produced === 'string' ? produced : produced.text;
+    const historySuffix = typeof produced === 'string' ? '' : (produced.historySuffix ?? '');
+    const assistantText = `${baseAssistantText}${historySuffix}`.trim();
     const kind = typeof produced === 'string' ? undefined : produced.kind;
     state.companionHistory = appendCompanionHistory(companionHistoryFor(state), [
         { role: 'user', content: userText },
@@ -638,7 +686,8 @@ messageHandlers.set('chat', async (ws, state, payload) => {
     }
     const turn = { cancelled: false, abortDelivered: false };
     state.activeTurn = turn;
-    const assistant = typeof assistantRaw === 'string' ? assistantRaw.trim() : 'agent';
+    const assistant = state.profile === 'agent' ? 'agent'
+        : typeof assistantRaw === 'string' ? assistantRaw.trim() : state.profile ?? 'agent';
     const peerId = typeof peerIdRaw === 'string' ? peerIdRaw.trim() : '';
     // Photos are accepted only for the companion; every other assistant keeps the
     // exact payload contract it had.
@@ -689,6 +738,7 @@ messageHandlers.set('chat', async (ws, state, payload) => {
                     const history = companionHistoryFor(state);
                     const produced = await produceCompanionReply(userText, {
                         history,
+                        userId: state.userId,
                         ...(imageAttachments.length ? { attachments: imageAttachments } : {}),
                     });
                     spoken = typeof produced === 'string' ? produced : produced.text;
@@ -1069,13 +1119,22 @@ messageHandlers.set('peer:request', async (ws, state, payload) => {
         sendError(ws, 'UNAUTHORIZED', 'Authentication required');
         return;
     }
-    if (!state.scopes.includes('peer:invoke')) {
-        sendError(ws, 'FORBIDDEN', 'peer:invoke scope required');
-        return;
-    }
     // payload is the request frame { id, method, params, traceId?, depth? }
     const frame = (payload ?? {});
     const requestId = frame.id ?? '';
+    if (!state.scopes.includes('peer:invoke')) {
+        // Match the rejected RPC so callers fail immediately instead of timing out.
+        send(ws, {
+            type: 'peer:response',
+            payload: {
+                id: requestId || 'unknown',
+                ok: false,
+                error: { code: 'FORBIDDEN', message: 'peer:invoke scope required' },
+            },
+            timestamp: new Date().toISOString(),
+        });
+        return;
+    }
     if (!checkRateLimit(state, 'peerRequestCount', 'peerWindowStart', RATE_LIMITS.peerRequestsPerMinute, 60_000)) {
         send(ws, {
             type: 'peer:response',
@@ -1165,9 +1224,28 @@ async function processMessage(ws, state, data) {
         ...(id ? { id } : {}),
         ...(requestId ? { requestId } : {}),
     };
+    const invoke = async () => {
+        if (type !== 'authenticate' && !deviceSessionIsActive(state)) {
+            state.authenticated = false;
+            state.approvalCapable = false;
+            abortActiveTurn(state);
+            sendError(ws, 'AUTH_FAILED', 'Invalid credentials', id);
+            return;
+        }
+        const run = () => handler(ws, state, payload ?? {}, envelope);
+        const withIdentity = () => state.profile || state.identity || state.amr
+            ? withDeviceSessionIdentity({
+                ...sessionIdentityClaims(state), ...(state.deviceId ? { deviceId: state.deviceId } : {}),
+            }, run)
+            : run();
+        if (state.profile === 'agent') {
+            return getPermissionModeManager().withModeAsync('default', () => ConfirmationService.getInstance().withApprovalContextAsync(`ws:${state.id}`, withIdentity));
+        }
+        return withIdentity();
+    };
     if (laneBypassMessageTypes.has(type)) {
         try {
-            await handler(ws, state, payload ?? {}, envelope);
+            await invoke();
         }
         catch (error) {
             sendError(ws, 'HANDLER_ERROR', error instanceof Error ? error.message : String(error), id);
@@ -1185,14 +1263,14 @@ async function processMessage(ws, state, data) {
                 ? payload
                 : {};
             const peerRequestId = typeof frame.id === 'string' ? frame.id : 'unknown';
-            await enqueuePeerHandler(state, () => enqueueMessage(`${sessionKey}:peer:${peerRequestId}`, () => handler(ws, state, payload ?? {}, envelope), {
+            await enqueuePeerHandler(state, () => enqueueMessage(`${sessionKey}:peer:${peerRequestId}`, invoke, {
                 parallel: true,
                 // Channel default is 120s; cold local Ollama peer.chat exceeded it (GK17).
                 timeout: PEER_REQUEST_LANE_TIMEOUT_MS,
             }));
         }
         else {
-            await enqueueMessage(sessionKey, () => handler(ws, state, payload ?? {}, envelope));
+            await enqueueMessage(sessionKey, invoke);
         }
     }
     catch (error) {
@@ -1267,6 +1345,7 @@ export async function setupWebSocket(server, config) {
         const state = {
             id: generateConnectionId(),
             authenticated: !config.authEnabled, // Auto-auth if auth disabled
+            deviceJwtSecret: config.jwtSecret,
             scopes: config.authEnabled
                 ? []
                 : [
@@ -1416,6 +1495,8 @@ function toBroadcastTarget(state) {
 export function collectApprovalSurfaceIds() {
     const ids = [];
     for (const state of connections.values()) {
+        if (!isMobilePwaEnabled() && state.profile !== 'agent')
+            continue;
         if (!state.authenticated)
             continue;
         if (state.anonymousRemote)
@@ -1424,6 +1505,8 @@ export function collectApprovalSurfaceIds() {
             continue;
         if (!state.scopes.includes('tools'))
             continue;
+        if (!deviceSessionIsActive(state))
+            continue;
         ids.push(state.id);
     }
     return ids;
@@ -1434,6 +1517,8 @@ export function broadcast(message, scopeFilter, targetFilter) {
     for (const [ws, state] of connections.entries()) {
         if (!state.authenticated)
             continue;
+        if (!deviceSessionIsActive(state))
+            continue;
         if (scopeFilter && !state.scopes.includes(scopeFilter))
             continue;
         if (targetFilter && !targetFilter(toBroadcastTarget(state)))

package/dist/services/prompt-builder.d.ts

@@ -130,6 +130,8 @@ export declare class PromptBuilder {
      * would otherwise tempt the LLM to hallucinate JSON tool calls.
      */
     buildForQuery(message: string, systemPromptId: string | undefined, modelName: string, customInstructions: string | null): Promise<string>;
+    /** Keep prompt reads bound to the same project/bot manager as tool writes. */
+    setPersistentMemory(manager: PersistentMemoryManager): void;
     /**
      * Update configuration
      */

package/dist/services/prompt-builder.js

@@ -515,16 +515,20 @@ export class PromptBuilder {
                         const { getCodeExplorerManager } = await import('../plugins/code-explorer/CodeExplorerManager.js');
                         const fresh = getCodeExplorerManager(this.config.cwd).getFreshness();
                         if (fresh.stale) {
-                            const behind = fresh.commitsBehind !== undefined ? `${fresh.commitsBehind} commit(s)` : 'some commits';
+                            const state = fresh.unverified
+                                ? 'could not be verified against Git HEAD'
+                                : 'does not match Git HEAD';
                             staleNote =
-                                `\n⚠️ The Code Explorer index is STALE — built at commit ${fresh.lastCommit?.slice(0, 8) ?? '?'}, ` +
-                                    `now ${behind} behind HEAD. Its answers may miss recent code; treat relationship results as ` +
-                                    `approximate and suggest re-running \`code-explorer analyze --incremental\` if they look wrong.`;
+                                `\n⚠️ The Code Explorer index ${state}. Its answers may miss current code; ` +
+                                    `treat relationship results as approximate and suggest re-running ` +
+                                    `\`code-explorer analyze --incremental\` if they look wrong.`;
                         }
                     }
                     catch { /* freshness best-effort */ }
                     const codeExplorerBlock = `<code_explorer_priority>\n` +
-                        `Code Explorer is connected. For ANY question about code relationships — ` +
+                        `Code Explorer is connected through MCP on the host. Use these MCP tools directly; ` +
+                        `do not run the host code-explorer binary through Bash, which may execute inside an isolated container. ` +
+                        `For questions about code relationships — ` +
                         `callers/callees, blast radius / impact ("what breaks if I change X"), dead code, cycles, ` +
                         `coupling, complexity — PREFER its MCP tools (\`${p}impact\`, ` +
                         `\`${p}context\`, \`${p}query\`, \`${p}find_cycles\`, …) ` +
@@ -921,6 +925,10 @@ Output formatting discipline:
         });
         return this.buildSystemPrompt(systemPromptId, modelName, customInstructions, gates, message);
     }
+    /** Keep prompt reads bound to the same project/bot manager as tool writes. */
+    setPersistentMemory(manager) {
+        this.persistentMemory = manager;
+    }
     /**
      * Update configuration
      */

package/dist/services/runtime-settings-context.d.ts

@@ -0,0 +1,73 @@
+export interface RuntimeSettingsEvidence {
+    surface?: string;
+    model?: string;
+    provider?: string;
+    maxToolRounds?: number;
+}
+/** Explicit allowlist: never serialize configuration objects, env, endpoints or credentials. */
+export declare function getRuntimeSettingsSnapshot(evidence?: RuntimeSettingsEvidence): {
+    guidance: string;
+    fleet?: {
+        supported: boolean;
+        configuredConnections: number;
+        statusTool: string;
+        statusArguments: {
+            includeCapabilities: boolean;
+        };
+        delegationTool: string;
+        routingTool: string;
+        connectionCommand: string;
+        scope: string;
+    } | undefined;
+    theme: {
+        active: string;
+        available: (string | undefined)[];
+        customOverrides: {
+            colors: string[];
+            avatars: string[];
+        };
+        lastPreferenceSave: boolean | null;
+        changeCommand: string;
+        statusCommand: string;
+    };
+    permissionMode?: import("../security/permission-modes.js").PermissionMode | undefined;
+    programmaticToolCalling: {
+        guidance?: string | undefined;
+        tool: string;
+        policy: import("../config/code-exec-policy.js").CodeExecPolicy;
+        source: "default" | "model" | "env";
+    };
+    maxToolRounds?: number | undefined;
+    surface: string;
+    model: string;
+    provider: string;
+} | {
+    guidance: string;
+    fleet?: {
+        supported: boolean;
+        configuredConnections: number;
+        statusTool: string;
+        statusArguments: {
+            includeCapabilities: boolean;
+        };
+        delegationTool: string;
+        routingTool: string;
+        connectionCommand: string;
+        scope: string;
+    } | undefined;
+    theme: null;
+    permissionMode?: import("../security/permission-modes.js").PermissionMode | undefined;
+    programmaticToolCalling: {
+        guidance?: string | undefined;
+        tool: string;
+        policy: import("../config/code-exec-policy.js").CodeExecPolicy;
+        source: "default" | "model" | "env";
+    };
+    maxToolRounds?: number | undefined;
+    surface: string;
+    model: string;
+    provider: string;
+};
+export declare function formatRuntimeSettingsContext(evidence: RuntimeSettingsEvidence): string;
+/** Ensure operational questions can reach the existing tools even with RAG selection. */
+export declare function runtimeInspectionTools(query: string): string[];

package/dist/services/runtime-settings-context.js

@@ -0,0 +1,69 @@
+import { getThemeManager } from '../themes/theme-manager.js';
+import { getFleetRegistry } from '../fleet/fleet-registry.js';
+import { getPermissionModeManager } from '../security/permission-modes.js';
+import { CODE_EXEC_OFF_NOTICE, CODE_EXEC_PREFER_HINT, resolveCodeExecPolicy } from '../config/code-exec-policy.js';
+function identifier(value) {
+    return typeof value === 'string' && /^[a-zA-Z0-9_.:/-]{1,160}$/.test(value) ? value : undefined;
+}
+/** P5: effective code_exec policy and its short model-facing guidance. */
+function programmaticToolCallingSnapshot(model) {
+    const resolved = resolveCodeExecPolicy(identifier(model));
+    return {
+        tool: 'code_exec',
+        policy: resolved.policy,
+        source: resolved.source,
+        ...(resolved.policy === 'prefer' ? { guidance: CODE_EXEC_PREFER_HINT } : {}),
+        ...(resolved.policy === 'off' ? { guidance: CODE_EXEC_OFF_NOTICE } : {}),
+    };
+}
+/** Explicit allowlist: never serialize configuration objects, env, endpoints or credentials. */
+export function getRuntimeSettingsSnapshot(evidence = {}) {
+    const cli = evidence.surface === 'cli';
+    const manager = cli ? getThemeManager() : undefined;
+    return {
+        surface: identifier(evidence.surface) ?? 'unknown',
+        model: identifier(evidence.model) ?? 'unknown',
+        provider: identifier(evidence.provider) ?? 'unknown',
+        ...(Number.isSafeInteger(evidence.maxToolRounds) && evidence.maxToolRounds > 0
+            ? { maxToolRounds: evidence.maxToolRounds } : {}),
+        programmaticToolCalling: programmaticToolCallingSnapshot(evidence.model),
+        ...(cli ? { permissionMode: getPermissionModeManager().getMode() } : {}),
+        ...(manager ? {
+            theme: {
+                active: identifier(manager.getCurrentTheme().id) ?? 'custom',
+                available: manager.getAvailableThemes().map(theme => identifier(theme.id)).filter(Boolean),
+                customOverrides: manager.getOverrideKeys(),
+                lastPreferenceSave: manager.getPreferenceSaveStatus(),
+                changeCommand: '/theme <id>',
+                statusCommand: '/theme status',
+            },
+        } : { theme: null }),
+        ...(cli ? { fleet: {
+                supported: true,
+                configuredConnections: getFleetRegistry().list().length,
+                statusTool: 'list_peers',
+                statusArguments: { includeCapabilities: true },
+                delegationTool: 'peer_delegate',
+                routingTool: 'route_peer',
+                connectionCommand: '/fleet listen <ws-url> --name <id>',
+                scope: 'Configured connections only; an empty registry does not prove no other Buddy is running on the network. Do not claim local-only capability. Probe list_peers before asserting availability.',
+            } } : {}),
+        guidance: 'Live settings at observation time. Unknown values are not inferred from saved preferences. A null theme means no CLI theme is attested for this surface. Theme changes require /theme <id>; editing a config file alone does not apply a live change.',
+    };
+}
+export function formatRuntimeSettingsContext(evidence) {
+    return '<runtime_settings ephemeral="true">\n' +
+        JSON.stringify(getRuntimeSettingsSnapshot(evidence)) + '\n</runtime_settings>';
+}
+/** Ensure operational questions can reach the existing tools even with RAG selection. */
+export function runtimeInspectionTools(query) {
+    const text = query.normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase();
+    if (/\b(fleet|flotte|peers?|autres? (?:code[ -]?)?budd(?:y|ies)|other (?:code[ -]?)?budd(?:y|ies)|instances? (?:actives?|buddy)|buddy.*ensemble)\b/.test(text)) {
+        return ['list_peers', 'route_peer', 'peer_delegate'];
+    }
+    if (/\b(theme|parametres?|parametrage|settings|configuration actuelle|current configuration)\b/.test(text)) {
+        return ['self_describe'];
+    }
+    return [];
+}
+//# sourceMappingURL=runtime-settings-context.js.map

package/dist/skills/executor.js

@@ -6,6 +6,7 @@
 import { EventEmitter } from 'events';
 import { SkillVariableResolver } from './skill-enhancements.js';
 import { resolveBashInjections } from './bash-injection.js';
+import { recordSkillActivity } from './skill-usage-store.js';
 export const DEFAULT_EXECUTOR_CONFIG = {
     timeout: 60000,
     stepMode: false,
@@ -29,6 +30,7 @@ export class SkillExecutor extends EventEmitter {
         const startTime = Date.now();
         const toolCalls = [];
         this.emit('skill:start', skill, context);
+        recordSkillActivity(skill.metadata.name, 'use', { source: 'executor' });
         try {
             // Check requirements
             const reqCheck = this.checkRequirements(skill, context);

package/dist/skills/hub.js

@@ -23,19 +23,21 @@ export { generateSkillSigningKeyPair, signSkillContent, signRegistryIndexPayload
 // ============================================================================
 // Constants
 // ============================================================================
-const DEFAULT_HUB_CONFIG = {
-    registryUrl: 'https://hub.codebuddy.dev/api/v1',
-    cacheDir: path.join(os.homedir(), '.codebuddy', 'hub', 'cache'),
-    skillsDir: path.join(os.homedir(), '.codebuddy', 'skills', 'managed'),
-    lockfilePath: path.join(os.homedir(), '.codebuddy', 'hub', 'lock.json'),
-    tapsPath: path.join(os.homedir(), '.codebuddy', 'hub', 'taps.json'),
-    trustedKeysPath: path.join(os.homedir(), '.codebuddy', 'hub', 'trusted-keys.json'),
-    requireSignedInstalls: false,
-    githubApiBaseUrl: 'https://api.github.com',
-    githubRawBaseUrl: 'https://raw.githubusercontent.com',
-    autoUpdate: false,
-    checkIntervalMs: 24 * 60 * 60 * 1000, // 24 hours
-};
+function defaultHubConfig() {
+    return {
+        registryUrl: 'https://hub.codebuddy.dev/api/v1',
+        cacheDir: path.join(os.homedir(), '.codebuddy', 'hub', 'cache'),
+        skillsDir: path.join(os.homedir(), '.codebuddy', 'skills', 'managed'),
+        lockfilePath: path.join(os.homedir(), '.codebuddy', 'hub', 'lock.json'),
+        tapsPath: path.join(os.homedir(), '.codebuddy', 'hub', 'taps.json'),
+        trustedKeysPath: path.join(os.homedir(), '.codebuddy', 'hub', 'trusted-keys.json'),
+        requireSignedInstalls: false,
+        githubApiBaseUrl: 'https://api.github.com',
+        githubRawBaseUrl: 'https://raw.githubusercontent.com',
+        autoUpdate: false,
+        checkIntervalMs: 24 * 60 * 60 * 1000, // 24 hours
+    };
+}
 const LOCKFILE_VERSION = 1;
 const TAPS_FILE_VERSION = 1;
 const TRUSTED_KEYS_FILE_VERSION = 1;
@@ -107,7 +109,7 @@ export class SkillsHub extends EventEmitter {
     cacheTtlMs = 5 * 60 * 1000; // 5 minutes
     constructor(config = {}) {
         super();
-        this.config = { ...DEFAULT_HUB_CONFIG, ...config };
+        this.config = { ...defaultHubConfig(), ...config };
         this.lockfile = this.readLockfile();
         this.ensureDirectories();
     }

package/dist/skills/local-inventory.d.ts

@@ -0,0 +1,21 @@
+import type { InstalledSkillStatus } from './hub.js';
+import type { SkillRequirements } from './types.js';
+export interface LocalSkillEntry {
+    name: string;
+    description: string;
+    source: string;
+    path?: string;
+    version?: string;
+    requires?: SkillRequirements;
+    available: boolean;
+    reason?: 'disabled' | 'missing-file' | 'integrity-mismatch' | 'invalid-skill';
+}
+/** Read the same local skill tiers without activating skills or starting watchers. */
+export declare function readLocalSkillInventory(installed: InstalledSkillStatus[]): Promise<{
+    entries: LocalSkillEntry[];
+    errors: Array<{
+        path: string;
+        message: string;
+    }>;
+}>;
+export declare function readLocalSkillContent(skill: LocalSkillEntry): Promise<string>;

package/dist/skills/local-inventory.js

@@ -0,0 +1,72 @@
+import { readFile } from 'fs/promises';
+import { getBundledSkillsPath } from './index.js';
+import { SkillRegistry } from './registry.js';
+import { SkillManager } from './skill-manager.js';
+/** Read the same local skill tiers without activating skills or starting watchers. */
+export async function readLocalSkillInventory(installed) {
+    const registry = new SkillRegistry({ bundledPath: getBundledSkillsPath(), watchEnabled: false });
+    const errors = [];
+    registry.on('skill:error', (path, error) => errors.push({ path, message: error.message }));
+    await registry.load();
+    const entries = new Map();
+    // Built-in legacy specializations still exposed by /skill. Do not load custom
+    // files through the legacy parser: SKILL.md files must pass registry validation.
+    const manager = new SkillManager();
+    for (const name of manager.getAvailableSkills()) {
+        const skill = manager.getSkill(name);
+        entries.set(name, { name, description: skill.description, source: 'builtin', available: true });
+    }
+    for (const skill of registry.list()) {
+        entries.set(skill.metadata.name, {
+            name: skill.metadata.name,
+            description: skill.metadata.description,
+            source: skill.tier,
+            path: skill.sourcePath,
+            version: skill.metadata.version,
+            requires: skill.metadata.requires,
+            available: skill.enabled !== false,
+            ...(skill.enabled === false ? { reason: 'disabled' } : {}),
+        });
+    }
+    for (const skill of installed) {
+        let previous = entries.get(skill.name);
+        let reason = skill.enabled === false ? 'disabled'
+            : !skill.exists ? 'missing-file'
+                : !skill.integrityOk ? 'integrity-mismatch' : undefined;
+        if (!reason) {
+            try {
+                const parsed = await registry.registerSkillFile(skill.path, 'managed');
+                if (registry.get(parsed.metadata.name)?.sourcePath !== skill.path) {
+                    reason = 'invalid-skill';
+                }
+                else {
+                    previous = { name: skill.name, description: parsed.metadata.description,
+                        source: 'hub', available: true, requires: parsed.metadata.requires };
+                }
+            }
+            catch (error) {
+                reason = 'invalid-skill';
+                errors.push({ path: skill.path, message: error instanceof Error ? error.message : String(error) });
+            }
+        }
+        // Hub lifecycle state takes precedence; never present a disabled or altered
+        // installed skill as usable via a same-name bundled fallback.
+        entries.set(skill.name, {
+            name: skill.name,
+            description: previous?.description ?? '',
+            requires: previous?.requires,
+            source: 'hub',
+            path: skill.path,
+            version: skill.version,
+            available: !reason,
+            ...(reason ? { reason } : {}),
+        });
+    }
+    return { entries: [...entries.values()], errors };
+}
+export async function readLocalSkillContent(skill) {
+    if (skill.path)
+        return readFile(skill.path, 'utf-8');
+    return new SkillManager().getSkill(skill.name)?.systemPrompt ?? '';
+}
+//# sourceMappingURL=local-inventory.js.map