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

package/control-plane/scripts/upstreams/stdio-client.mjs

@@ -0,0 +1,73 @@
+import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
+import { Client } from "@modelcontextprotocol/client";
+
+function withTimeout(promise, ms, label) {
+  let timer;
+  return Promise.race([
+    promise.finally(() => clearTimeout(timer)),
+    new Promise((_, reject) => {
+      timer = setTimeout(() => reject(new Error(`${label} timed out after ${ms}ms`)), ms);
+    })
+  ]);
+}
+
+export async function createStdioUpstreamClient(serverConfig) {
+  const transport = new StdioClientTransport({
+    command: serverConfig.command,
+    args: serverConfig.args || [],
+    cwd: serverConfig.cwd,
+    stderr: 'pipe',
+    windowsHide: true
+  });
+  let stderr = '';
+  let running = true;
+  transport.stderr?.on?.('data', chunk => {
+    stderr = `${stderr}${chunk.toString()}`.slice(-4000);
+  });
+  transport.onclose = () => { running = false; };
+  const client = new Client({ name: `agent-mcp-gateway-upstream-${serverConfig.id}`, version: '1.0.0' }, { capabilities: {} });
+  try {
+    await withTimeout(client.connect(transport), serverConfig.startupTimeoutMs || 15000, `upstream ${serverConfig.id} initialize`);
+  } catch (error) {
+    // A failed constructor cannot return its transport to the manager for shutdown.
+    await client.close().catch(() => {});
+    await transport.close().catch(() => {});
+    running = false;
+    throw error;
+  }
+  const capabilities = client.getServerCapabilities?.() || {};
+  return {
+    id: serverConfig.id,
+    config: serverConfig,
+    client,
+    transport,
+    capabilities,
+    get pid() { return transport.pid; },
+    get stderr() { return stderr; },
+    isRunning() { return running && Boolean(transport.pid); },
+    kill(signal = 'SIGTERM') {
+      if (!running) return false;
+      const pid = transport.pid;
+      if (!pid) return false;
+      try {
+        process.kill(pid, signal);
+        return true;
+      } catch {
+        running = false;
+        return false;
+      }
+    },
+    async listTools() { return await client.listTools(); },
+    async callTool(params) { return await client.callTool(params); },
+    async listResources() { return await client.listResources(); },
+    async listResourceTemplates() { return await client.listResourceTemplates(); },
+    async readResource(params) { return await client.readResource(params); },
+    async listPrompts() { return await client.listPrompts(); },
+    async getPrompt(params) { return await client.getPrompt(params); },
+    async close() {
+      await client.close().catch(() => {});
+      await transport.close().catch(() => {});
+      running = false;
+    }
+  };
+}

package/control-plane/scripts/workspace-registry.mjs

@@ -0,0 +1,147 @@
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import * as toml from 'smol-toml';
+
+import {
+  buildTrustedRootsProjectRegistryFromRaw,
+  trustedRootsTomlToRaw
+} from './projects/trusted-roots-projects.mjs';
+
+const DEFAULT_WATCH_INTERVAL_MS = 500;
+
+function hashText(text) {
+  return createHash('sha256').update(text).digest('hex');
+}
+
+function stableValue(value) {
+  if (Array.isArray(value)) return value.map(stableValue);
+  if (!value || typeof value !== 'object') return value;
+  return Object.fromEntries(Object.keys(value).sort().map(key => [key, stableValue(value[key])]));
+}
+
+function stableSignature(value) {
+  return hashText(JSON.stringify(stableValue(value)));
+}
+
+export function createWorkspaceRegistry(options = {}) {
+  const configPath = path.resolve(options.configPath);
+  const repoRoot = path.resolve(options.repoRoot || process.cwd());
+  const env = options.env || process.env;
+  const watchIntervalMs = options.watchIntervalMs ?? DEFAULT_WATCH_INTERVAL_MS;
+  const listeners = new Set();
+  let closed = false;
+  let state = null;
+  let reloadInFlight = null;
+
+  function buildState(content) {
+    const rawConfig = toml.parse(content || '');
+    const rawRoots = trustedRootsTomlToRaw(rawConfig.trusted_roots, { repoRoot });
+    const projectRegistry = buildTrustedRootsProjectRegistryFromRaw(rawRoots, {
+      defaultProjectId: env.MCP_DEFAULT_PROJECT_ID,
+      requireProjectId: false,
+      pathInference: true,
+      exposeProjectPaths: String(env.MCP_EXPOSE_PROJECT_PATHS || '').toLowerCase() === 'true',
+      checkExists: false
+    });
+    const roots = projectRegistry.allTrustedRoots.filter(root => fs.existsSync(root));
+    return {
+      configPath,
+      content,
+      hash: hashText(content),
+      stateSignature: hashText(content),
+      rawConfig,
+      roots,
+      rootsSignature: stableSignature(roots),
+      upstreamSignature: stableSignature({
+        external_mcp: rawConfig.external_mcp || {},
+        mcp_servers: rawConfig.mcp_servers || {}
+      }),
+      projectRegistry,
+      server: {
+        name: rawConfig.server?.name || 'agent-mcp-gateway',
+        title: rawConfig.server?.title || 'Local Coding Gateway',
+        description: rawConfig.server?.description || 'Local coding workspace for filesystem, shell, image inspection, and optional skills.',
+        instructions: rawConfig.server?.instructions || 'Use filesystem tools for content, shell_execute for terminal workflows, and image_preview for local images.'
+      },
+      loadedAt: new Date().toISOString(),
+      lastError: null
+    };
+  }
+
+  function publicSnapshot() {
+    return {
+      ...state,
+      roots: [...state.roots],
+      rawConfig: state.rawConfig,
+      projectRegistry: state.projectRegistry,
+      server: { ...state.server }
+    };
+  }
+
+  async function notify(previous, reason) {
+    const next = publicSnapshot();
+    for (const listener of listeners) {
+      await listener(next, previous, reason);
+    }
+  }
+
+  async function reloadFromDisk(reason = 'manual') {
+    if (reloadInFlight) {
+      await reloadInFlight;
+      return await reloadFromDisk(reason);
+    }
+    reloadInFlight = (async () => {
+      const previousState = state;
+      let candidatePublished = false;
+      try {
+        const content = await fs.promises.readFile(configPath, 'utf8');
+        const next = buildState(content);
+        if (state?.stateSignature === next.stateSignature) return { changed: false, snapshot: publicSnapshot() };
+        const previous = state ? publicSnapshot() : null;
+        state = next;
+        candidatePublished = true;
+        await notify(previous, reason);
+        return { changed: true, snapshot: publicSnapshot() };
+      } catch (error) {
+        if (!previousState) throw error;
+        const lastError = String(error?.message || error);
+        state = { ...(candidatePublished ? previousState : state), lastError };
+        console.error(`[workspace-registry] keeping last synchronized config: ${lastError}`);
+        return { changed: false, error, snapshot: publicSnapshot() };
+      } finally {
+        reloadInFlight = null;
+      }
+    })();
+    return await reloadInFlight;
+  }
+
+  const initialContent = fs.readFileSync(configPath, 'utf8');
+  state = buildState(initialContent);
+
+  const watchListener = () => {
+    if (!closed) reloadFromDisk('watch').catch(error => console.error(`[workspace-registry] reload failed: ${error.message}`));
+  };
+  fs.watchFile(configPath, { interval: watchIntervalMs, persistent: false }, watchListener);
+
+  return {
+    snapshot: publicSnapshot,
+    reloadFromDisk,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    close() {
+      closed = true;
+      fs.unwatchFile(configPath, watchListener);
+      listeners.clear();
+    }
+  };
+}
+
+export function classifyWorkspaceChange(next, previous) {
+  return {
+    rootsChanged: !previous || next.rootsSignature !== previous.rootsSignature,
+    upstreamChanged: !previous || next.upstreamSignature !== previous.upstreamSignature
+  };
+}

package/dist/context/authorization.d.ts

@@ -0,0 +1,5 @@
+export { SOC_PUBLIC_KEY } from '../device/official-trust.js';
+export type GatedFeature = 'FEATURE_LIVE_CAPTURE' | 'FEATURE_PUBLIC_GATEWAY';
+export declare const GATE_ERROR = "FEATURE_GATE_LOCKED: Phase 7/8 requires valid SOC security approval artifact";
+export declare function isFeatureAuthorized(scope: GatedFeature): boolean;
+export declare function requireFeatureAuthorized(scope: GatedFeature): void;

package/dist/context/authorization.js

@@ -0,0 +1,70 @@
+import { createHash } from 'node:crypto';
+import { readFileSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { verifyOfficialApproval } from '../device/official-trust.js';
+export { SOC_PUBLIC_KEY } from '../device/official-trust.js';
+export const GATE_ERROR = 'FEATURE_GATE_LOCKED: Phase 7/8 requires valid SOC security approval artifact';
+// Anchor trust configuration to the installed module, never the caller's cwd.
+const CONFIG_DIRECTORY = fileURLToPath(new URL('../../config/', import.meta.url));
+function approvalFailure(scope) {
+    try {
+        if (!['FEATURE_LIVE_CAPTURE', 'FEATURE_PUBLIC_GATEWAY'].includes(scope))
+            return GATE_ERROR;
+        const path = join(CONFIG_DIRECTORY, 'soc-approval.json');
+        if (statSync(path).size > 16384)
+            return GATE_ERROR;
+        const artifact = JSON.parse(readFileSync(path, 'utf8'));
+        if (artifact.schema_version !== 1 || !Array.isArray(artifact.features) || artifact.features.length < 1 || artifact.features.length > 2 ||
+            !artifact.features.every((value) => value === 'FEATURE_LIVE_CAPTURE' || value === 'FEATURE_PUBLIC_GATEWAY') ||
+            new Set(artifact.features).size !== artifact.features.length || !artifact.features.includes(scope) ||
+            !Number.isSafeInteger(artifact.expires_at) || artifact.expires_at <= Date.now() || typeof artifact.signature !== 'string')
+            return GATE_ERROR;
+        // RFC 8785 JCS for this closed schema: lexicographically sorted ASCII keys,
+        // safe integer time, ASCII enum strings, and order-preserving arrays. JSON's
+        // ECMAScript serialization is canonical for these validated value types.
+        if (!verifyOfficialApproval(artifact))
+            return `${GATE_ERROR}: SOC_KEY_UNTRUSTED`;
+        // Digest the canonical signed artifact, not file formatting: whitespace or
+        // insertion-order changes cannot resurrect a revoked approval.
+        const digest = createHash('sha256').update(JSON.stringify({
+            expires_at: artifact.expires_at, features: artifact.features,
+            schema_version: artifact.schema_version, signature: artifact.signature
+        })).digest('hex');
+        const revokedPath = join(CONFIG_DIRECTORY, 'revoked-approvals.json');
+        let revokedText;
+        try {
+            if (statSync(revokedPath).size > 1048576)
+                return GATE_ERROR;
+            revokedText = readFileSync(revokedPath, 'utf8');
+        }
+        catch {
+            return 'FEATURE_GATE_LOCKED: revocation list missing or unreadable';
+        }
+        let revoked;
+        try {
+            revoked = JSON.parse(revokedText);
+        }
+        catch {
+            return 'FEATURE_GATE_LOCKED: revocation list malformed';
+        }
+        if (!Array.isArray(revoked))
+            return 'FEATURE_GATE_LOCKED: revocation list malformed';
+        if (!revoked.every((value) => typeof value === 'string' && /^[0-9a-f]{64}$/.test(value)))
+            return 'FEATURE_GATE_LOCKED: revocation list malformed';
+        if (revoked.includes(digest))
+            return 'FEATURE_GATE_LOCKED: artifact revoked';
+        return undefined;
+    }
+    catch {
+        return GATE_ERROR;
+    }
+}
+export function isFeatureAuthorized(scope) {
+    return approvalFailure(scope) === undefined;
+}
+export function requireFeatureAuthorized(scope) {
+    const failure = approvalFailure(scope);
+    if (failure)
+        throw new Error(failure);
+}

package/dist/context/capture.d.ts

@@ -0,0 +1,46 @@
+import type { ContextStore } from './store.js';
+import type { ContextService } from './service.js';
+/** Importing this module never enables capture. Revalidate every privileged write. */
+export declare function executeLiveCapture<T>(action: () => T): T;
+export declare const EXCLUDED_LOCAL_TOOLS: readonly ["local_status", "local_search", "local_read", "local_graph", "local_index", "local_wiki", "get_recent_tool_calls", "track_ui_event"];
+export interface IntentRequest {
+    tool: string;
+    args?: Record<string, unknown>;
+    invocationId?: string;
+}
+export interface OutcomeData {
+    result?: unknown;
+    status: 'succeeded' | 'failed' | 'cancelled';
+    error?: string;
+    durationMs?: number;
+}
+export interface ObservedInvocation extends IntentRequest, OutcomeData {
+}
+export interface IntentToken extends IntentRequest {
+    ok: boolean;
+    invocationId: string;
+    eventId?: number;
+    gap?: boolean;
+    error?: string;
+}
+export interface ObservationOutcome {
+    recorded: boolean;
+    excluded?: boolean;
+    eventId?: number;
+    gapRecorded?: boolean;
+    error?: string;
+}
+export interface CanonicalObserver {
+    beginIntent(request: IntentRequest): Promise<IntentToken>;
+    completeOutcome(token: IntentToken, outcome: OutcomeData): Promise<ObservationOutcome>;
+    recordInvocation(invocation: ObservedInvocation): Promise<ObservationOutcome>;
+    execute<T>(request: IntentRequest, action: () => T | Promise<T>): Promise<T>;
+}
+/** Explicit trusted-runtime installation only; importing never activates hooks. */
+export declare function setLiveCaptureObserver(observer: CanonicalObserver | undefined): void;
+export declare function isCapturingInvocation(): boolean;
+export declare function observePublicInvocation<T>(request: IntentRequest, action: () => T | Promise<T>, observer?: CanonicalObserver | undefined): Promise<T>;
+/** One public invocation -> one durable intent -> one outcome. No execution retries.
+ * Capture uses short SQLite lock budgets, the shared quota/fencing admission and
+ * bounded redacted payloads. Failures remain in memory, never on the execution path. */
+export declare function createCanonicalObserver(service: ContextService, store: ContextStore, owner: string, repo: string): CanonicalObserver;

package/dist/context/capture.js

@@ -0,0 +1,187 @@
+import { randomBytes, randomUUID } from 'node:crypto';
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { requireFeatureAuthorized } from './authorization.js';
+/** Importing this module never enables capture. Revalidate every privileged write. */
+export function executeLiveCapture(action) {
+    try {
+        requireFeatureAuthorized('FEATURE_LIVE_CAPTURE');
+    }
+    catch (error) {
+        liveObserver = undefined;
+        throw error;
+    }
+    return action();
+}
+export const EXCLUDED_LOCAL_TOOLS = ['local_status', 'local_search', 'local_read', 'local_graph',
+    'local_index', 'local_wiki', 'get_recent_tool_calls', 'track_ui_event'];
+const excluded = (tool) => tool.startsWith('local_') || EXCLUDED_LOCAL_TOOLS.some(name => name === tool);
+const activeCapture = new AsyncLocalStorage();
+let liveObserver;
+/** Explicit trusted-runtime installation only; importing never activates hooks. */
+export function setLiveCaptureObserver(observer) {
+    if (observer)
+        executeLiveCapture(() => { liveObserver = observer; });
+    else
+        liveObserver = undefined;
+}
+export function isCapturingInvocation() { return activeCapture.getStore() === true; }
+export async function observePublicInvocation(request, action, observer = liveObserver) {
+    if (!observer || isCapturingInvocation())
+        return action();
+    return activeCapture.run(true, () => observer.execute(request, action));
+}
+/** One public invocation -> one durable intent -> one outcome. No execution retries.
+ * Capture uses short SQLite lock budgets, the shared quota/fencing admission and
+ * bounded redacted payloads. Failures remain in memory, never on the execution path. */
+export function createCanonicalObserver(service, store, owner, repo) {
+    store.authorize(owner, repo);
+    const completed = new WeakSet();
+    const bounded = (action) => {
+        const db = store.repoDatabase(owner, repo), registry = store.registry;
+        const connections = [registry, db, store.unscopedDatabase(owner)];
+        const budgets = connections.map(connection => Number(connection.prepare('PRAGMA busy_timeout').get()?.timeout));
+        try {
+            for (const connection of connections)
+                connection.exec('PRAGMA busy_timeout=25');
+            return action();
+        }
+        finally {
+            connections.forEach((connection, index) => connection.exec(`PRAGMA busy_timeout=${budgets[index]}`));
+        }
+    };
+    const gap = (reason, error) => {
+        service.recordGap(owner, repo, reason);
+        return error instanceof Error ? error.message : String(error);
+    };
+    const observer = {
+        async beginIntent(request) {
+            executeLiveCapture(() => service.requireFeatureAuthorized('FEATURE_LIVE_CAPTURE'));
+            const token = { ...request, invocationId: request.invocationId ?? randomUUID(), ok: false };
+            if (excluded(request.tool))
+                return token;
+            return executeLiveCapture(() => {
+                service.requireFeatureAuthorized('FEATURE_LIVE_CAPTURE');
+                try {
+                    token.eventId = bounded(() => store.quotaWrite(owner, repo, 65536, () => {
+                        const db = store.repoDatabase(owner, repo);
+                        db.exec('BEGIN IMMEDIATE');
+                        try {
+                            const row = db.prepare("INSERT INTO events(invocation_id,accepted_at,execution_status) VALUES(?,?,'pending')").run(token.invocationId, Date.now());
+                            store.commitRepository(db);
+                            return Number(row.lastInsertRowid);
+                        }
+                        catch (error) {
+                            if (db.isTransaction)
+                                db.exec('ROLLBACK');
+                            throw error;
+                        }
+                    }));
+                    token.ok = true;
+                }
+                catch (error) {
+                    token.gap = true;
+                    const message = error instanceof Error ? error.message : String(error);
+                    let reason = 'storage_unavailable';
+                    if (/busy|locked/i.test(message))
+                        reason = 'busy';
+                    else if (/QUOTA/.test(message))
+                        reason = 'quota';
+                    token.error = gap(reason, error);
+                }
+                return token;
+            });
+        },
+        async completeOutcome(token, outcome) {
+            executeLiveCapture(() => service.requireFeatureAuthorized('FEATURE_LIVE_CAPTURE'));
+            if (excluded(token.tool))
+                return { recorded: false, excluded: true };
+            if (!token.ok || token.eventId === undefined)
+                return { recorded: false, gapRecorded: token.gap };
+            if (completed.has(token))
+                return { recorded: true, eventId: token.eventId };
+            const eventId = token.eventId;
+            try {
+                return executeLiveCapture(() => {
+                    service.requireFeatureAuthorized('FEATURE_LIVE_CAPTURE');
+                    return bounded(() => {
+                        const prior = store.repoDatabase(owner, repo).prepare('SELECT payload_ref FROM events WHERE event_id=? AND invocation_id=?').get(eventId, token.invocationId);
+                        if (prior?.payload_ref) {
+                            completed.add(token);
+                            return { recorded: true, eventId };
+                        }
+                        const process = outcome.result?._meta?.process;
+                        // Poll duration is not source evidence. Identical canonical output/range
+                        // payloads reuse their redacted keyed hash, scoped to this repository.
+                        const canonicalRange = Boolean(process?.execution_id && process?.runtime_generation && process?.read_from !== undefined);
+                        const payload = canonicalRange
+                            ? { tool: token.tool, result: outcome.result, status: outcome.status }
+                            : { tool: token.tool, args: token.args ?? {}, ...outcome };
+                        const safe = store.redactPayload(JSON.stringify(payload), { maxBytes: 65536 });
+                        store.quotaWrite(owner, repo, safe.retainedBytes * 4 + 65536, () => {
+                            const db = store.repoDatabase(owner, repo);
+                            const existing = canonicalRange
+                                ? db.prepare("SELECT ref FROM evidence WHERE hash=? AND retention_state='available' LIMIT 1").get(safe.hash) : undefined;
+                            const ref = existing ? String(existing.ref) : randomBytes(24).toString('hex');
+                            db.exec('BEGIN IMMEDIATE');
+                            try {
+                                if (!existing)
+                                    db.prepare('INSERT INTO evidence(ref,text,hash,original_bytes,retained_bytes,redaction_state,partial) VALUES(?,?,?,?,?,?,?)')
+                                        .run(ref, safe.text, safe.hash, safe.originalBytes, safe.retainedBytes, safe.state, Number(safe.partial));
+                                db.prepare('UPDATE events SET execution_status=?,recording_status=\'committed\',payload_ref=? WHERE event_id=? AND invocation_id=?')
+                                    .run(outcome.status, ref, eventId, token.invocationId);
+                                store.commitRepository(db);
+                            }
+                            catch (error) {
+                                if (db.isTransaction)
+                                    db.exec('ROLLBACK');
+                                throw error;
+                            }
+                        });
+                        completed.add(token);
+                        return { recorded: true, eventId };
+                    });
+                });
+            }
+            catch (error) {
+                const message = gap('outcome_failed', error);
+                // Best effort metadata only. Never bypass revoked authorization.
+                try {
+                    executeLiveCapture(() => bounded(() => {
+                        store.repoDatabase(owner, repo).prepare("UPDATE events SET execution_status=?,recording_status='degraded' WHERE event_id=?").run(outcome.status, eventId);
+                    }));
+                }
+                catch { /* The durable pending intent will become unknown after restart. */ }
+                return { recorded: false, gapRecorded: true, error: message };
+            }
+        },
+        async recordInvocation(invocation) {
+            return observer.completeOutcome(await observer.beginIntent(invocation), invocation);
+        },
+        async execute(request, action) {
+            const token = await observer.beginIntent(request), start = Date.now();
+            // Revocation stops observation, not an already executed tool's result/error.
+            const finish = async (outcome) => {
+                try {
+                    await observer.completeOutcome(token, outcome);
+                }
+                catch (error) {
+                    if (!(error instanceof Error) || !error.message.startsWith('FEATURE_GATE_LOCKED'))
+                        throw error;
+                    service.recordGap(owner, repo, 'authorization_revoked');
+                }
+            };
+            let result;
+            try {
+                result = await action();
+            }
+            catch (error) {
+                await finish({ status: 'failed', error: error instanceof Error ? error.message : String(error), durationMs: Date.now() - start });
+                throw error;
+            }
+            const failed = result !== null && typeof result === 'object' && ('isError' in result && result.isError === true || 'exitCode' in result && result.exitCode !== 0);
+            await finish({ result, status: failed ? 'failed' : 'succeeded', durationMs: Date.now() - start });
+            return result;
+        }
+    };
+    return observer;
+}

package/dist/context/cli.d.ts

@@ -0,0 +1,47 @@
+import { type PathGuard } from './repositories.js';
+export declare const CONTEXT_CLI_CONTRACT: {
+    readonly globalFlags: readonly ["--cwd", "--json"];
+    readonly commands: readonly [{
+        readonly name: "status";
+        readonly flags: readonly [];
+    }, {
+        readonly name: "search";
+        readonly flags: readonly ["--query", "--limit", "--max-bytes", "--cursor", "--source-type", "--since", "--until"];
+    }, {
+        readonly name: "read";
+        readonly flags: readonly ["--ref", "--max-bytes", "--cursor"];
+    }, {
+        readonly name: "graph";
+        readonly flags: readonly ["--ref", "--action", "--target", "--direction", "--max-hops", "--max-nodes", "--max-edges", "--max-visited", "--max-bytes", "--wall-ms", "--generation"];
+    }, {
+        readonly name: "sync";
+        readonly flags: readonly [];
+    }, {
+        readonly name: "checkpoint";
+        readonly flags: readonly ["--summary", "--evidence-ref"];
+    }, {
+        readonly name: "rebuild";
+        readonly flags: readonly [];
+    }, {
+        readonly name: "cancel";
+        readonly flags: readonly ["--job-ref"];
+    }];
+};
+export interface ContextCliResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export interface ContextCliDependencies {
+    stateRoot?: string;
+    pathGuard?: PathGuard;
+    workingDirectory?: string;
+}
+export declare function contextCliHelp(): string;
+/** Operator-only gate. Exclusive claim serializes validation and consumption.
+ * Token files contain {token: 64 lowercase hex, expires_at: epoch milliseconds}.
+ * The protected state root is an OS permission boundary, not an agent sandbox.
+ */
+export declare function consumeAdminToken(root: string, token: string, now?: number): void;
+/** Isolated local adapter. It opens device-local state and calls ContextService only. */
+export declare function runContextCli(argv: string[], deps?: ContextCliDependencies): Promise<ContextCliResult>;