@hcu-lab.me/mcp-device 1.0.10 → 1.0.12

package/dist/context/text.d.ts

@@ -0,0 +1,4 @@
+/** Match Vietnamese stroked d as well as combining accents on both sides of FTS. */
+export declare function fold(text: string): string;
+/** Return a byte-bounded prefix without splitting UTF-8 code points or surrogate pairs. */
+export declare function utf8Prefix(text: string, cap: number): string;

package/dist/context/text.js

@@ -0,0 +1,14 @@
+/** Match Vietnamese stroked d as well as combining accents on both sides of FTS. */
+export function fold(text) {
+    return text.replace(/[đĐ]/g, 'd').normalize('NFD').replace(/\p{M}/gu, '').toLowerCase();
+}
+/** Return a byte-bounded prefix without splitting UTF-8 code points or surrogate pairs. */
+export function utf8Prefix(text, cap) {
+    if (Buffer.byteLength(text) <= cap)
+        return text;
+    const buffer = Buffer.from(text);
+    let end = Math.min(cap, buffer.length);
+    while (end > 0 && (buffer[end] & 0xc0) === 0x80)
+        end--;
+    return buffer.subarray(0, end).toString('utf8');
+}

package/dist/context/tool-contract.d.ts

@@ -0,0 +1,534 @@
+import { z } from 'zod';
+export declare const CONTEXT_INPUTS: {
+    readonly local_status: z.ZodObject<{
+        check_current: z.ZodOptional<z.ZodBoolean>;
+        job_id: z.ZodOptional<z.ZodString>;
+        device_id: z.ZodString;
+        cwd: z.ZodOptional<z.ZodString>;
+        project_id: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        device_id: string;
+        cwd?: string | undefined;
+        check_current?: boolean | undefined;
+        job_id?: string | undefined;
+        project_id?: string | undefined;
+    }, {
+        device_id: string;
+        cwd?: string | undefined;
+        check_current?: boolean | undefined;
+        job_id?: string | undefined;
+        project_id?: string | undefined;
+    }>;
+    readonly local_search: z.ZodObject<{
+        query: z.ZodString;
+        source_types: z.ZodOptional<z.ZodArray<z.ZodEnum<["history", "checkpoint", "activity"]>, "many">>;
+        since: z.ZodOptional<z.ZodString>;
+        until: z.ZodOptional<z.ZodString>;
+        limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        max_bytes: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        cursor: z.ZodOptional<z.ZodString>;
+        include_related: z.ZodOptional<z.ZodBoolean>;
+        device_id: z.ZodString;
+        cwd: z.ZodOptional<z.ZodString>;
+        project_id: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        device_id: string;
+        query: string;
+        since?: string | undefined;
+        cwd?: string | undefined;
+        cursor?: string | undefined;
+        limit?: number | undefined;
+        project_id?: string | undefined;
+        source_types?: ("checkpoint" | "history" | "activity")[] | undefined;
+        until?: string | undefined;
+        max_bytes?: number | undefined;
+        include_related?: boolean | undefined;
+    }, {
+        device_id: string;
+        query: string;
+        since?: string | undefined;
+        cwd?: string | undefined;
+        cursor?: string | undefined;
+        limit?: number | undefined;
+        project_id?: string | undefined;
+        source_types?: ("checkpoint" | "history" | "activity")[] | undefined;
+        until?: string | undefined;
+        max_bytes?: number | undefined;
+        include_related?: boolean | undefined;
+    }>;
+    readonly local_read: z.ZodObject<{
+        refs: z.ZodArray<z.ZodString, "many">;
+        max_bytes: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        cursor: z.ZodOptional<z.ZodString>;
+        ranges: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            ref: z.ZodString;
+            start: z.ZodNumber;
+            end: z.ZodOptional<z.ZodNumber>;
+        }, "strict", z.ZodTypeAny, {
+            ref: string;
+            start: number;
+            end?: number | undefined;
+        }, {
+            ref: string;
+            start: number;
+            end?: number | undefined;
+        }>, "many">>;
+        device_id: z.ZodString;
+        cwd: z.ZodOptional<z.ZodString>;
+        project_id: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        device_id: string;
+        refs: string[];
+        cwd?: string | undefined;
+        cursor?: string | undefined;
+        project_id?: string | undefined;
+        max_bytes?: number | undefined;
+        ranges?: {
+            ref: string;
+            start: number;
+            end?: number | undefined;
+        }[] | undefined;
+    }, {
+        device_id: string;
+        refs: string[];
+        cwd?: string | undefined;
+        cursor?: string | undefined;
+        project_id?: string | undefined;
+        max_bytes?: number | undefined;
+        ranges?: {
+            ref: string;
+            start: number;
+            end?: number | undefined;
+        }[] | undefined;
+    }>;
+    readonly local_graph: z.ZodObject<{
+        action: z.ZodEnum<["neighbors", "path", "timeline", "related"]>;
+        refs: z.ZodArray<z.ZodString, "many">;
+        target: z.ZodOptional<z.ZodString>;
+        relations: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        direction: z.ZodOptional<z.ZodEnum<["in", "out", "both"]>>;
+        max_hops: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        max_nodes: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        max_edges: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        max_bytes: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        wall_ms: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        cursor: z.ZodOptional<z.ZodString>;
+        device_id: z.ZodString;
+        cwd: z.ZodOptional<z.ZodString>;
+        project_id: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        action: "path" | "neighbors" | "timeline" | "related";
+        device_id: string;
+        refs: string[];
+        target?: string | undefined;
+        cwd?: string | undefined;
+        cursor?: string | undefined;
+        project_id?: string | undefined;
+        max_bytes?: number | undefined;
+        relations?: string[] | undefined;
+        direction?: "out" | "in" | "both" | undefined;
+        max_hops?: number | undefined;
+        max_nodes?: number | undefined;
+        max_edges?: number | undefined;
+        wall_ms?: number | undefined;
+    }, {
+        action: "path" | "neighbors" | "timeline" | "related";
+        device_id: string;
+        refs: string[];
+        target?: string | undefined;
+        cwd?: string | undefined;
+        cursor?: string | undefined;
+        project_id?: string | undefined;
+        max_bytes?: number | undefined;
+        relations?: string[] | undefined;
+        direction?: "out" | "in" | "both" | undefined;
+        max_hops?: number | undefined;
+        max_nodes?: number | undefined;
+        max_edges?: number | undefined;
+        wall_ms?: number | undefined;
+    }>;
+    readonly local_index: z.ZodObject<{
+        action: z.ZodEnum<["sync", "checkpoint", "rebuild", "cancel"]>;
+        budget_profile: z.ZodOptional<z.ZodString>;
+        idempotency_key: z.ZodOptional<z.ZodString>;
+        job_id: z.ZodOptional<z.ZodString>;
+        summary: z.ZodOptional<z.ZodString>;
+        evidence_refs: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        device_id: z.ZodString;
+        cwd: z.ZodOptional<z.ZodString>;
+        project_id: z.ZodOptional<z.ZodString>;
+    }, "strict", z.ZodTypeAny, {
+        action: "checkpoint" | "sync" | "rebuild" | "cancel";
+        device_id: string;
+        evidence_refs?: string[] | undefined;
+        summary?: string | undefined;
+        cwd?: string | undefined;
+        job_id?: string | undefined;
+        project_id?: string | undefined;
+        budget_profile?: string | undefined;
+        idempotency_key?: string | undefined;
+    }, {
+        action: "checkpoint" | "sync" | "rebuild" | "cancel";
+        device_id: string;
+        evidence_refs?: string[] | undefined;
+        summary?: string | undefined;
+        cwd?: string | undefined;
+        job_id?: string | undefined;
+        project_id?: string | undefined;
+        budget_profile?: string | undefined;
+        idempotency_key?: string | undefined;
+    }>;
+    readonly local_wiki: z.ZodObject<{
+        action: z.ZodEnum<["status"]>;
+    }, "strict", z.ZodTypeAny, {
+        action: "status";
+    }, {
+        action: "status";
+    }>;
+};
+export type ContextToolName = keyof typeof CONTEXT_INPUTS;
+export declare const CONTEXT_TOOL_NAMES: ContextToolName[];
+export declare function buildContextCatalog(): {
+    name: "local_status" | "local_search" | "local_read" | "local_graph" | "local_index" | "local_wiki";
+    description: string;
+    inputSchema: {
+        type: "string";
+        minLength?: number;
+        maxLength?: number;
+        format?: "email" | "idn-email" | "uri" | "uuid" | "date-time" | "ipv4" | "ipv6" | "date" | "time" | "duration";
+        pattern?: string;
+        allOf?: {
+            pattern: string;
+            errorMessage?: import("zod-to-json-schema").ErrorMessages<{
+                pattern: string;
+            }>;
+        }[];
+        anyOf?: {
+            format: string;
+            errorMessage?: import("zod-to-json-schema").ErrorMessages<{
+                format: string;
+            }>;
+        }[];
+        errorMessage?: import("zod-to-json-schema").ErrorMessages<import("zod-to-json-schema").JsonSchema7StringType>;
+        contentEncoding?: string;
+        title?: string;
+        default?: any;
+        description?: string;
+        markdownDescription?: string;
+        definitions?: {
+            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+        } | undefined;
+    } | {
+        type: "array";
+        items?: import("zod-to-json-schema").JsonSchema7Type;
+        minItems?: number;
+        maxItems?: number;
+        errorMessages?: import("zod-to-json-schema").ErrorMessages<import("zod-to-json-schema").JsonSchema7ArrayType, "items">;
+        title?: string;
+        default?: any;
+        description?: string;
+        markdownDescription?: string;
+        definitions?: {
+            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+        } | undefined;
+    } | {
+        type: "number" | "integer";
+        minimum?: number;
+        exclusiveMinimum?: number;
+        maximum?: number;
+        exclusiveMaximum?: number;
+        multipleOf?: number;
+        errorMessage?: import("zod-to-json-schema").ErrorMessages<import("zod-to-json-schema").JsonSchema7NumberType>;
+        title?: string;
+        default?: any;
+        description?: string;
+        markdownDescription?: string;
+        definitions?: {
+            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+        } | undefined;
+    } | {
+        type: "integer";
+        format: "int64";
+        minimum?: BigInt;
+        exclusiveMinimum?: BigInt;
+        maximum?: BigInt;
+        exclusiveMaximum?: BigInt;
+        multipleOf?: BigInt;
+        errorMessage?: import("zod-to-json-schema").ErrorMessages<import("zod-to-json-schema").JsonSchema7BigintType>;
+        title?: string;
+        default?: any;
+        description?: string;
+        markdownDescription?: string;
+        definitions?: {
+            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+        } | undefined;
+    } | {
+        type: "boolean";
+        title?: string;
+        default?: any;
+        description?: string;
+        markdownDescription?: string;
+        definitions?: {
+            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+        } | undefined;
+    } | {
+        type: "integer" | "string";
+        format: "unix-time" | "date-time" | "date";
+        minimum?: number;
+        maximum?: number;
+        errorMessage?: import("zod-to-json-schema").ErrorMessages<import("zod-to-json-schema").JsonSchema7NumberType>;
+        title?: string;
+        default?: any;
+        description?: string;
+        markdownDescription?: string;
+        definitions?: {
+            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+        } | undefined;
+    } | {
+        anyOf: import("zod-to-json-schema").JsonSchema7DateType[];
+        title?: string;
+        default?: any;
+        description?: string;
+        markdownDescription?: string;
+        definitions?: {
+            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+        } | undefined;
+    } | {
+        type: "string";
+        enum: string[];
+        title?: string;
+        default?: any;
+        description?: string;
+        markdownDescription?: string;
+        definitions?: {
+            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+        } | undefined;
+    } | {
+        type: "string" | "number" | "integer" | "boolean";
+        const: string | number | boolean;
+        title?: string;
+        default?: any;
+        description?: string;
+        markdownDescription?: string;
+        definitions?: {
+            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+        } | undefined;
+    } | {
+        type: "object" | "array";
+        title?: string;
+        default?: any;
+        description?: string;
+        markdownDescription?: string;
+        definitions?: {
+            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+        } | undefined;
+    } | {
+        type: "string" | "number" | ["string", "number"];
+        enum: (string | number)[];
+        title?: string;
+        default?: any;
+        description?: string;
+        markdownDescription?: string;
+        definitions?: {
+            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+        } | undefined;
+    } | {
+        type: "null";
+        title?: string;
+        default?: any;
+        description?: string;
+        markdownDescription?: string;
+        definitions?: {
+            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+        } | undefined;
+    } | {
+        type: "object";
+        properties: Record<string, import("zod-to-json-schema").JsonSchema7Type>;
+        additionalProperties?: boolean | import("zod-to-json-schema").JsonSchema7Type;
+        required?: string[];
+        title?: string;
+        default?: any;
+        description?: string;
+        markdownDescription?: string;
+        definitions?: {
+            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+        } | undefined;
+    } | {
+        type: "object";
+        additionalProperties?: import("zod-to-json-schema").JsonSchema7Type | true;
+        propertyNames?: Omit<import("zod-to-json-schema").JsonSchema7StringType, "type"> | Omit<import("zod-to-json-schema").JsonSchema7EnumType, "type">;
+        title?: string;
+        default?: any;
+        description?: string;
+        markdownDescription?: string;
+        definitions?: {
+            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+        } | undefined;
+    } | {
+        type: "array";
+        minItems: number;
+        items: import("zod-to-json-schema").JsonSchema7Type[];
+        maxItems: number;
+        title?: string;
+        default?: any;
+        description?: string;
+        markdownDescription?: string;
+        definitions?: {
+            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+        } | undefined;
+    } | {
+        type: "array";
+        minItems: number;
+        items: import("zod-to-json-schema").JsonSchema7Type[];
+        additionalItems?: import("zod-to-json-schema").JsonSchema7Type;
+        title?: string;
+        default?: any;
+        description?: string;
+        markdownDescription?: string;
+        definitions?: {
+            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+        } | undefined;
+    } | {
+        type: ("string" | "number" | "boolean" | "null" | "integer") | ("string" | "number" | "boolean" | "null" | "integer")[];
+        title?: string;
+        default?: any;
+        description?: string;
+        markdownDescription?: string;
+        definitions?: {
+            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+        } | undefined;
+    } | {
+        type: ("string" | "number" | "boolean" | "null" | "integer") | ("string" | "number" | "boolean" | "null" | "integer")[];
+        enum: (string | number | bigint | boolean | null)[];
+        title?: string;
+        default?: any;
+        description?: string;
+        markdownDescription?: string;
+        definitions?: {
+            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+        } | undefined;
+    } | {
+        anyOf: import("zod-to-json-schema").JsonSchema7Type[];
+        title?: string;
+        default?: any;
+        description?: string;
+        markdownDescription?: string;
+        definitions?: {
+            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+        } | undefined;
+    } | {
+        not: import("zod-to-json-schema").JsonSchema7AnyType;
+        title?: string;
+        default?: any;
+        description?: string;
+        markdownDescription?: string;
+        definitions?: {
+            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+        } | undefined;
+    } | {
+        $ref: string;
+        title?: string;
+        default?: any;
+        description?: string;
+        markdownDescription?: string;
+        definitions?: {
+            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+        } | undefined;
+    } | {
+        not: import("zod-to-json-schema").JsonSchema7AnyType;
+        title?: string;
+        default?: any;
+        description?: string;
+        markdownDescription?: string;
+        definitions?: {
+            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+        } | undefined;
+    } | {
+        type: "array";
+        maxItems: 125;
+        items: {
+            type: "array";
+            items: [import("zod-to-json-schema").JsonSchema7Type, import("zod-to-json-schema").JsonSchema7Type];
+            minItems: 2;
+            maxItems: 2;
+        };
+        title?: string;
+        default?: any;
+        description?: string;
+        markdownDescription?: string;
+        definitions?: {
+            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+        } | undefined;
+    } | {
+        $ref?: string;
+        title?: string;
+        default?: any;
+        description?: string;
+        markdownDescription?: string;
+        definitions?: {
+            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+        } | undefined;
+    } | {
+        anyOf: [import("zod-to-json-schema").JsonSchema7Type, import("zod-to-json-schema").JsonSchema7NullType];
+        title?: string;
+        default?: any;
+        description?: string;
+        markdownDescription?: string;
+        definitions?: {
+            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+        } | undefined;
+    } | {
+        type: [string, "null"];
+        title?: string;
+        default?: any;
+        description?: string;
+        markdownDescription?: string;
+        definitions?: {
+            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+        } | undefined;
+    } | {
+        allOf: import("zod-to-json-schema").JsonSchema7Type[];
+        unevaluatedProperties?: boolean;
+        title?: string;
+        default?: any;
+        description?: string;
+        markdownDescription?: string;
+        definitions?: {
+            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+        } | undefined;
+    } | {
+        type: "array";
+        uniqueItems: true;
+        items?: import("zod-to-json-schema").JsonSchema7Type;
+        minItems?: number;
+        maxItems?: number;
+        errorMessage?: import("zod-to-json-schema").ErrorMessages<import("zod-to-json-schema").JsonSchema7SetType>;
+        title?: string;
+        default?: any;
+        description?: string;
+        markdownDescription?: string;
+        definitions?: {
+            [key: string]: import("zod-to-json-schema").JsonSchema7Type;
+        } | undefined;
+    };
+    annotations: {
+        readOnlyHint: boolean;
+        idempotentHint: boolean;
+        destructiveHint: boolean;
+        openWorldHint: boolean;
+    };
+    risk_lane: "read" | "write";
+}[];
+export declare function validateContextInput(name: string, input: unknown): Record<string, any>;
+export declare const WIKI_DISABLED: {
+    readonly ok: false;
+    readonly code: "WIKI_DISABLED";
+    readonly enabled: false;
+    readonly implementation_feature: "003-manual-repo-wiki";
+};
+export declare function contextError(error: unknown): {
+    ok: false;
+    error: {
+        code: string;
+    };
+};

package/dist/context/tool-contract.js

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+const scope = { device_id: z.string().min(1), cwd: z.string().optional(), project_id: z.string().optional() };
+const strings = z.array(z.string());
+const cap = (maximum, fallback) => z.number().int().min(1).max(maximum).default(fallback).optional();
+export const CONTEXT_INPUTS = {
+    local_status: z.object({ ...scope, check_current: z.boolean().optional(), job_id: z.string().optional() }).strict(),
+    local_search: z.object({ ...scope, query: z.string().min(1), source_types: z.array(z.enum(['history', 'checkpoint', 'activity'])).optional(), since: z.string().optional(), until: z.string().optional(), limit: cap(50, 8), max_bytes: cap(131072, 32768), cursor: z.string().optional(), include_related: z.boolean().optional() }).strict(),
+    local_read: z.object({ ...scope, refs: strings.min(1).max(20), max_bytes: cap(1048576, 262144), cursor: z.string().optional(), ranges: z.array(z.object({ ref: z.string(), start: z.number().int().min(0), end: z.number().int().min(0).optional() }).strict()).max(20).optional() }).strict(),
+    local_graph: z.object({ ...scope, action: z.enum(['neighbors', 'path', 'timeline', 'related']), refs: strings, target: z.string().optional(), relations: strings.optional(), direction: z.enum(['in', 'out', 'both']).optional(), max_hops: cap(4, 2), max_nodes: cap(200, 50), max_edges: cap(2000, 500), max_bytes: cap(131072, 65536), wall_ms: cap(100, 25), cursor: z.string().optional() }).strict(),
+    local_index: z.object({ ...scope, action: z.enum(['sync', 'checkpoint', 'rebuild', 'cancel']), budget_profile: z.string().optional(), idempotency_key: z.string().optional(), job_id: z.string().optional(), summary: z.string().optional(), evidence_refs: strings.optional() }).strict(),
+    local_wiki: z.object({ action: z.enum(['status']) }).strict(),
+};
+export const CONTEXT_TOOL_NAMES = Object.keys(CONTEXT_INPUTS);
+const descriptions = {
+    local_status: 'Inspect bounded local context freshness, storage, capture gaps and jobs. No indexing.',
+    local_search: 'Search retained history, checkpoints and activity in the published generation. No hidden sync.',
+    local_read: 'Read retained evidence in ref order within aggregate byte bounds, never current source substitution.',
+    local_graph: 'Query bounded activity/provenance relations, not source-code or causal similarity.',
+    local_index: 'Explicit retained-event sync, checkpoint, derived rebuild or job cancel. No destructive administration.',
+    local_wiki: 'Reserved disabled wiki status. No provider calls in feature 002.',
+};
+export function buildContextCatalog() {
+    return CONTEXT_TOOL_NAMES.map(name => {
+        const { $schema: _schema, ...inputSchema } = zodToJsonSchema(CONTEXT_INPUTS[name], { $refStrategy: 'none' });
+        return { name, description: descriptions[name], inputSchema, annotations: {
+                readOnlyHint: name !== 'local_index', idempotentHint: name !== 'local_index', destructiveHint: false, openWorldHint: false,
+            }, risk_lane: name === 'local_index' ? 'write' : 'read' };
+    });
+}
+export function validateContextInput(name, input) {
+    const schema = CONTEXT_INPUTS[name];
+    if (!schema || !schema.safeParse(input).success)
+        throw new Error('ACTION_UNSUPPORTED');
+    // Validation never materializes schema defaults: preserve CLI/domain defaults.
+    return input;
+}
+export const WIKI_DISABLED = { ok: false, code: 'WIKI_DISABLED', enabled: false, implementation_feature: '003-manual-repo-wiki' };
+const SAFE_ERRORS = new Set(['DEVICE_UNSUPPORTED', 'DEVICE_OFFLINE', 'SCOPE_REQUIRED', 'SCOPE_AMBIGUOUS', 'ACCESS_DENIED', 'LOCAL_STATE_UNAVAILABLE', 'REPOSITORY_NOT_FOUND', 'INDEX_MISSING', 'INDEX_INCOMPATIBLE', 'REF_NOT_FOUND', 'EVIDENCE_EXPIRED', 'CURSOR_INVALID', 'CURSOR_STALE', 'BUSY', 'BUDGET_EXCEEDED', 'STORAGE_DEGRADED', 'ACTION_UNSUPPORTED', 'WIKI_DISABLED']);
+export function contextError(error) {
+    const message = error instanceof Error ? error.message : '';
+    const code = error?.code;
+    const safe = SAFE_ERRORS.has(message) ? message : code && SAFE_ERRORS.has(code) ? code : ['EACCES', 'EPERM', 'EROFS', 'ENOTDIR', 'ENOENT'].includes(code ?? '') ? 'LOCAL_STATE_UNAVAILABLE' : 'INTERNAL_ERROR';
+    return { ok: false, error: { code: safe } };
+}

package/dist/device/core.d.ts

@@ -0,0 +1,29 @@
+export interface DeviceCoreOptions {
+    deviceId: string;
+    /** Must match MCP_DEVICE_CONFIG_DIR before existing Device modules are imported. */
+    stateRoot?: string;
+    allowedRoots?: string[];
+}
+export interface DeviceCore {
+    readonly deviceId: string;
+    readonly stateRoot: string;
+    readonly runtimeInstanceId: string;
+    /** Existing broker capabilities; native tools retain their separate contracts. */
+    readonly capabilities: string[];
+    invoke(tool: string, args?: unknown): Promise<any>;
+    /** The existing rich native surface, without rewriting it into broker arguments. */
+    invokeNative(tool: string, args?: unknown): Promise<any>;
+    close(): Promise<void>;
+}
+/**
+ * The transport-neutral execution owner shared by remote Device and server.
+ *
+ * No account enrollment, socket, self-MCP child, plugin, or Palace is created
+ * here. Authorization belongs to the caller's broker; file/process semantics
+ * remain owned by the existing Device handlers and GatewayToolAdapter.
+ *
+ * Existing native managers are process-scoped. A server must configure its
+ * isolated state root before importing them; silently changing a global root
+ * after import could write to the user's normal Device state.
+ */
+export declare function createDeviceCore(options: DeviceCoreOptions): Promise<DeviceCore>;