@contextecf/guardian-cli 0.1.0

package/dist/packages/guardian-cli/src/runtime.d.ts

@@ -0,0 +1,523 @@
+import type { Writable } from 'node:stream';
+import { type PolicyPackMarketplaceManifest } from '@contextecf/personal-fabric-contracts';
+import { SQLitePersonalFabricStore, type PersonalFabricDataImportResult, type PersonalFabricMutableDataDeleteResult, type SQLitePersonalFabricBackupResult } from '@contextecf/personal-fabric-store';
+export declare const GUARDIAN_CLI_VERSION = "0.1.0";
+export declare const GUARDIAN_PROFILE_SCHEMA_VERSION = "contextecf/project-guardian-profile/v1";
+export declare const GUARDIAN_NPM_PACKAGE_NAME = "@contextecf/guardian-cli";
+export declare const GUARDIAN_GLOBAL_INSTALL_COMMAND = "npm install -g @contextecf/guardian-cli";
+export declare const GUARDIAN_NPX_SETUP_COMMAND = "npx @contextecf/guardian-cli@latest setup";
+export declare const GUARDIAN_FIRST_RUN_COMMAND = "guardian setup";
+export declare const GUARDIAN_OPEN_CONTROL_TOWER_COMMAND = "guardian launch";
+export declare const GUARDIAN_CONTROL_TOWER_URL_ENV = "GUARDIAN_CONTROL_TOWER_URL";
+export declare const GUARDIAN_DEFAULT_CONTROL_TOWER_URL = "http://127.0.0.1:4317/control-tower";
+export declare const GUARDIAN_LOCAL_DATA_ENCRYPTION_KEY_ENV = "GUARDIAN_LOCAL_DATA_ENCRYPTION_KEY";
+export declare const GUARDIAN_LOCAL_DATA_ENCRYPTION_KEY_ID_ENV = "GUARDIAN_LOCAL_DATA_ENCRYPTION_KEY_ID";
+export declare const GUARDIAN_SQLITE_PAGE_ENCRYPTION_KEY_ENV = "GUARDIAN_SQLITE_PAGE_ENCRYPTION_KEY";
+export declare const GUARDIAN_SQLITE_PAGE_ENCRYPTION_KEY_ID_ENV = "GUARDIAN_SQLITE_PAGE_ENCRYPTION_KEY_ID";
+export declare const GUARDIAN_DESKTOP_ADAPTER_SIMULATE_OPEN_ENV = "GUARDIAN_DESKTOP_ADAPTER_SIMULATE_OPEN";
+export declare const GUARDIAN_DESKTOP_URL_OPEN_ADAPTER_ID = "guardian_desktop_url_open";
+export declare const GUARDIAN_DESKTOP_URL_OPEN_ADAPTER_VERSION = "1.0.0";
+export declare const GUARDIAN_DESKTOP_URL_OPEN_ADAPTER_PROOF_SCHEMA_VERSION = "contextecf/project-guardian-desktop-url-open-adapter-proof/v1";
+export declare const GUARDIAN_SERVICE_PROOF_SCHEMA_VERSION = "contextecf/project-guardian-service-supervision/v1";
+export declare const GUARDIAN_OS_KEY_STORAGE_PROOF_SCHEMA_VERSION = "contextecf/project-guardian-os-key-storage/v1";
+export declare const GUARDIAN_WINDOWS_NATIVE_HOST_REGISTRY_PROOF_SCHEMA_VERSION = "contextecf/project-guardian-windows-native-host-registry/v1";
+export interface GuardianCliOptions {
+    env?: NodeJS.ProcessEnv;
+    platform?: NodeJS.Platform;
+    now?: () => Date;
+    stdout?: Pick<Writable, 'write'>;
+    stderr?: Pick<Writable, 'write'>;
+    openUrl?: (url: string) => Promise<void>;
+    startMcpServer?: () => Promise<void>;
+    startDetachedDaemon?: (request: GuardianDetachedDaemonStartRequest) => Promise<GuardianDetachedDaemonStartResult>;
+    healthDaemon?: (request: GuardianDaemonHealthRequest) => Promise<GuardianDaemonHealthResult>;
+    stopDaemon?: (request: GuardianDaemonStopRequest) => Promise<GuardianDaemonStopResult>;
+    startDaemonServer?: (request: GuardianDaemonServeRequest) => Promise<GuardianDaemonServerHandle>;
+    executeDesktopAction?: (request: GuardianDesktopActionExecutionRequest) => Promise<GuardianDesktopActionExecutionResult>;
+    executeOsKeyStorageCommand?: (request: GuardianOsKeyStorageCommandRequest) => Promise<GuardianOsKeyStorageCommandResult>;
+    executeWindowsRegistryCommand?: (request: GuardianWindowsRegistryCommandRequest) => Promise<GuardianWindowsRegistryCommandResult>;
+}
+export interface GuardianDaemonServeRequest {
+    home: string;
+    host: string;
+    port: number;
+}
+export interface GuardianDetachedDaemonStartRequest extends GuardianDaemonServeRequest {
+}
+export interface GuardianDetachedDaemonStartResult {
+    url: string;
+    pid?: number;
+}
+export interface GuardianDaemonStopRequest {
+    url: string;
+    token: string;
+}
+export interface GuardianDaemonStopResult {
+    ok: boolean;
+    statusCode?: number;
+    error?: string;
+}
+export interface GuardianDaemonHealthRequest {
+    url: string;
+    token: string;
+}
+export interface GuardianDaemonHealthResult {
+    ok: boolean;
+    reachable: boolean;
+    statusCode?: number;
+    service?: string;
+    rawContentPersistence?: boolean;
+    error?: string;
+}
+export interface GuardianDesktopActionExecutionRequest {
+    adapter: typeof GUARDIAN_DESKTOP_URL_OPEN_ADAPTER_ID;
+    adapterVersion: typeof GUARDIAN_DESKTOP_URL_OPEN_ADAPTER_VERSION;
+    actionId: string;
+    appId: string;
+    actionType: 'open';
+    targetRef: string;
+    targetRefHash: `sha256:${string}`;
+    planId: string;
+    planHash: `sha256:${string}`;
+}
+export interface GuardianDesktopActionExecutionResult {
+    executed: boolean;
+    adapter: typeof GUARDIAN_DESKTOP_URL_OPEN_ADAPTER_ID;
+    adapterVersion: typeof GUARDIAN_DESKTOP_URL_OPEN_ADAPTER_VERSION;
+    opened: boolean;
+    simulated?: boolean;
+}
+export interface GuardianProductionGateEvidenceStatus {
+    schemaVersion: string;
+    releaseClaim: string;
+    status: 'production_allowed' | 'production_blocked';
+    productionClaimAllowed: boolean;
+    validatorCommand?: string;
+    matrixPath?: string;
+    evidencePath?: string;
+    matrixSha256?: string;
+    provenGateCount?: number;
+    notProvenGateCount?: number;
+    notProvenGates?: Array<{
+        id: string;
+        label: string;
+        owner?: string;
+        runtimeBoundary?: string;
+        releaseBoundary?: string;
+        evidencePacket?: string;
+        evidenceRequiredFields?: string[];
+        closesWhen?: string[];
+    }>;
+}
+export interface GuardianReleaseEvidenceStatus {
+    installedFromProtectedArtifact: boolean;
+    status: 'missing' | 'verified' | 'invalid';
+    evidencePath: string;
+    schemaVersion?: string;
+    generatedAt?: string;
+    gitCommit?: string;
+    packageName?: string;
+    packageVersion?: string;
+    checksumCount?: number;
+    boundaries?: {
+        expectedFileCount?: number;
+        sourceFilesIncluded?: boolean;
+        sourceMapsIncluded?: boolean;
+        unpublishedWorkspaceRuntimeImports?: boolean;
+    };
+    publishDryRun?: {
+        enabled: boolean;
+        status: 'passed' | 'skipped' | 'not_recorded';
+        command?: string;
+        packageName?: string;
+        packageVersion?: string;
+        filename?: string;
+    };
+    productionGateEvidence?: GuardianProductionGateEvidenceStatus;
+    error?: string;
+}
+declare const PROMPT_COACH_MODES: readonly ["off", "quiet", "balanced", "hands_on"];
+export type GuardianPromptCoachMode = (typeof PROMPT_COACH_MODES)[number];
+export declare const GUARDIAN_POSTURE_PROFILE_IDS: readonly ["calm", "balanced", "guided", "high_assurance", "autopilot_lite"];
+export type GuardianPostureProfileId = (typeof GUARDIAN_POSTURE_PROFILE_IDS)[number];
+export interface GuardianPostureProfileDefinition {
+    id: GuardianPostureProfileId;
+    displayName: string;
+    summary: string;
+    coachCadence: 'minimal' | 'standard' | 'active';
+    contextAppetite: 'low' | 'standard' | 'rich';
+    confirmationLevel: 'strict' | 'standard' | 'high_assurance';
+    localActionTrustCeiling: 'confirm' | 'restricted_autopilot_lite';
+    learningDefault: 'off' | 'suggest_opt_in';
+    receiptDetail: 'metadata_only' | 'metadata_plus_policy_detail';
+}
+export declare const GUARDIAN_POSTURE_PROFILE_CATALOG: readonly GuardianPostureProfileDefinition[];
+export declare const GUARDIAN_POLICY_PACK_MARKETPLACE_CATALOG: readonly PolicyPackMarketplaceManifest[];
+export declare const GUARDIAN_PROVIDER_IDS: readonly ["chatgpt", "claude", "gemini", "perplexity", "cursor", "windsurf", "openrouter", "local_model", "unknown"];
+export type GuardianProviderId = (typeof GUARDIAN_PROVIDER_IDS)[number];
+export declare const GUARDIAN_SOURCE_TYPES: readonly ["files", "folders", "calendar", "email", "notes", "tasks", "contacts", "downloads", "clipboard", "browser", "cloud_drives"];
+export type GuardianSourceTypeId = (typeof GUARDIAN_SOURCE_TYPES)[number];
+export interface GuardianDaemonServerHandle {
+    url: string;
+    close: () => Promise<void>;
+    closed: Promise<void>;
+}
+export type GuardianServiceSupervisorPlatform = 'launchd' | 'systemd' | 'windows-task-scheduler';
+export type GuardianOsKeyStoragePlatform = 'macos-keychain' | 'windows-dpapi' | 'linux-secret-service';
+export interface GuardianWindowsRegistryCommandRequest {
+    action: 'add' | 'delete';
+    executable: 'reg';
+    args: string[];
+}
+export interface GuardianWindowsRegistryCommandResult {
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}
+export interface GuardianServiceSupervisionProof {
+    schema_version: typeof GUARDIAN_SERVICE_PROOF_SCHEMA_VERSION;
+    installed_at: string;
+    platform: GuardianServiceSupervisorPlatform;
+    serviceName: string;
+    profileDir: string;
+    daemonUrl: string;
+    controlTowerUrl: string;
+    artifactPath: string;
+    artifactSha256: `sha256:${string}`;
+    registrationMode: 'artifact_only';
+    osRegistered: false;
+    command: string;
+    args: string[];
+    startCommand: string;
+    stopCommand: string;
+    statusCommand: string;
+    uninstallCommand: string;
+    tokenPrinted: false;
+    rawContentIncluded: false;
+}
+export interface GuardianServiceSupervisionStatus {
+    schema_version: typeof GUARDIAN_SERVICE_PROOF_SCHEMA_VERSION;
+    installed: boolean;
+    status: 'missing' | 'verified' | 'invalid';
+    platform?: GuardianServiceSupervisorPlatform;
+    serviceName?: string;
+    profileDir: string;
+    daemonUrl?: string;
+    controlTowerUrl?: string;
+    artifactPath: string;
+    proofPath: string;
+    artifactSha256?: `sha256:${string}`;
+    registrationMode?: 'artifact_only';
+    osRegistered: false;
+    tokenPrinted: false;
+    rawContentIncluded: false;
+    error?: string;
+    nextCommands: string[];
+}
+export interface GuardianOsKeyStorageCommandRequest {
+    platform: GuardianOsKeyStoragePlatform;
+    action: 'store' | 'probe' | 'delete';
+    command: string;
+    args: string[];
+    input?: string;
+    redactedCommand: string;
+}
+export interface GuardianOsKeyStorageCommandResult {
+    ok: boolean;
+    statusCode?: number;
+    stdout?: string;
+    stderr?: string;
+}
+export interface GuardianOsKeyStorageProof {
+    schema_version: typeof GUARDIAN_OS_KEY_STORAGE_PROOF_SCHEMA_VERSION;
+    installed_at: string;
+    platform: GuardianOsKeyStoragePlatform;
+    profileDir: string;
+    keyId: string;
+    keySha256: `sha256:${string}`;
+    credentialService: string;
+    credentialAccount: string;
+    proofPath: string;
+    storageCommand: string;
+    probeCommand: string;
+    deleteCommand: string;
+    osBackedKeyStorage: 'verified';
+    secretInputVia: 'stdin';
+    secretInCommandArgs: false;
+    commandExecuted: true;
+    tokenPrinted: false;
+    keyPrinted: false;
+    rawContentIncluded: false;
+}
+export interface GuardianOsKeyStorageStatus {
+    schema_version: typeof GUARDIAN_OS_KEY_STORAGE_PROOF_SCHEMA_VERSION;
+    installed: boolean;
+    status: 'missing' | 'verified' | 'invalid';
+    platform?: GuardianOsKeyStoragePlatform;
+    profileDir: string;
+    keyId?: string;
+    credentialService?: string;
+    credentialAccount?: string;
+    proofPath: string;
+    osBackedKeyStorage: 'missing' | 'verified' | 'invalid';
+    secretInputVia?: 'stdin';
+    secretInCommandArgs: false;
+    tokenPrinted: false;
+    keyPrinted: false;
+    rawContentIncluded: false;
+    error?: string;
+    nextCommands: string[];
+}
+export interface GuardianProfile {
+    schema_version: typeof GUARDIAN_PROFILE_SCHEMA_VERSION;
+    installed_at: string;
+    profile_dir: string;
+    runtime: {
+        daemon_status: 'not_started_mvp' | 'start_requested';
+        loopback_auth: 'token_file';
+        mcp_stdio_available: boolean;
+    };
+    control_tower: {
+        url: string;
+        source: 'default_loopback' | 'env_or_flag';
+    };
+    privacy: {
+        privacy_mode_enabled: true;
+        raw_content_capture_enabled: false;
+        cloud_sync_enabled: false;
+        local_app_autopilot_enabled: false;
+    };
+    policy_packs: {
+        active: string[];
+        available: string[];
+    };
+    posture_profile: {
+        selected: GuardianPostureProfileId;
+        available: GuardianPostureProfileId[];
+        managed: boolean;
+        managed_baseline_id?: string;
+        updated_at?: string;
+    };
+    permissions: {
+        revoked_app_ids: string[];
+        revoked_provider_ids: GuardianProviderId[];
+        revoked_source_types: GuardianSourceTypeId[];
+    };
+    prompt_coach_mode: GuardianPromptCoachMode;
+    learning_graph: {
+        enabled: boolean;
+        prompt_coach_interruption_budget: {
+            daily_soft_card_limit: number;
+            repeated_dismissal_quieting: boolean;
+        };
+    };
+    receipts: {
+        raw_content_included: false;
+    };
+}
+export interface DoctorCheck {
+    id: string;
+    label: string;
+    status: 'pass' | 'warn' | 'fail';
+    detail: string;
+}
+export interface GuardianNotProvenProductionGate {
+    id: string;
+    label: string;
+    boundary: string;
+    owner: string;
+    runtimeBoundary: string;
+    releaseBoundary: string;
+    evidencePacket: string;
+    evidenceRequiredFields: readonly string[];
+    closesWhen: readonly string[];
+}
+export declare const GUARDIAN_NOT_PROVEN_PRODUCTION_GATES: readonly GuardianNotProvenProductionGate[];
+export interface GuardianDoctorStatus {
+    schema_version: 'contextecf/project-guardian-doctor/v1';
+    cli_version: typeof GUARDIAN_CLI_VERSION;
+    profile_dir: string;
+    overall: 'pass' | 'warn' | 'fail';
+    checkCounts: {
+        pass: number;
+        warn: number;
+        fail: number;
+    };
+    checks: DoctorCheck[];
+    notProvenProductionGates: readonly GuardianNotProvenProductionGate[];
+    tokenPrinted: false;
+    rawContentIncluded: false;
+}
+export interface GuardianProductionReadinessStatus {
+    schema_version: 'contextecf/project-guardian-production-readiness/v1';
+    cli_version: typeof GUARDIAN_CLI_VERSION;
+    profile_dir: string;
+    installed: boolean;
+    doctorOverall: GuardianDoctorStatus['overall'];
+    npmPreview: {
+        status: 'ready' | 'not_ready';
+        reason: string;
+        protectedEvidenceStatus: GuardianReleaseEvidenceStatus['status'];
+        publishDryRunStatus: NonNullable<GuardianReleaseEvidenceStatus['publishDryRun']>['status'];
+        publishCommand: string | null;
+    };
+    fullProduction: {
+        status: 'ready' | 'blocked';
+        reason: string;
+        blockedGateCount: number;
+        blockedGates: readonly GuardianNotProvenProductionGate[];
+        productionGateEvidenceStatus: GuardianProductionGateEvidenceStatus['status'] | 'not_recorded';
+        productionGateEvidencePath?: string;
+    };
+    tokenPrinted: false;
+    rawContentIncluded: false;
+}
+export type GuardianPolicyPackAction = 'enable' | 'disable';
+export interface GuardianPolicyPackControlResult {
+    success: true;
+    action: GuardianPolicyPackAction;
+    policyPackId: string;
+    active: string[];
+    available: string[];
+    userManaged: true;
+}
+export interface GuardianPreferenceControlResult {
+    success: true;
+    preference: 'prompt_coach_mode' | 'learning_graph';
+    value: string;
+    promptCoachMode: GuardianPromptCoachMode;
+    learningGraphEnabled: boolean;
+    userManaged: true;
+}
+export interface GuardianPostureProfileControlResult {
+    success: true;
+    selected: GuardianPostureProfileId;
+    available: GuardianPostureProfileId[];
+    profile: GuardianPostureProfileDefinition;
+    managed: boolean;
+    managedBaselineId?: string;
+    userManaged: true;
+}
+export interface GuardianPrivacyControlResult {
+    success: true;
+    privacyModeEnabled: true;
+    rawContentCaptureEnabled: false;
+    cloudSyncEnabled: false;
+    localAppAutopilotEnabled: false;
+    encryptedAtRest: false;
+    encryptionStatus: 'not_proven';
+    userManaged: true;
+}
+export type GuardianAppPermissionAction = 'revoke' | 'allow';
+export interface GuardianAppPermissionControlResult {
+    success: true;
+    action: GuardianAppPermissionAction;
+    scope: 'app' | 'provider' | 'source';
+    targetId: string;
+    appId: string;
+    revokedAppIds: string[];
+    revokedProviderIds: GuardianProviderId[];
+    revokedSourceTypes: GuardianSourceTypeId[];
+    userManaged: true;
+}
+export type GuardianDataLifecycleAction = 'export' | 'backup' | 'restore' | 'delete';
+export type GuardianDataLifecycleResult = {
+    success: true;
+    action: 'export';
+    profileDir: string;
+    outputPath: string;
+    exportHash: string;
+    contextPackageHash?: never;
+    rawContentIncluded: false;
+    tokenPrinted: false;
+} | ({
+    success: true;
+    action: 'backup';
+    profileDir: string;
+    rawContentIncluded: false;
+    tokenPrinted: false;
+} & SQLitePersonalFabricBackupResult) | ({
+    success: true;
+    action: 'restore';
+    profileDir: string;
+    inputPath: string;
+    rawContentIncluded: false;
+    tokenPrinted: false;
+} & PersonalFabricDataImportResult) | ({
+    success: true;
+    action: 'delete';
+    profileDir: string;
+    rawContentIncluded: false;
+    tokenPrinted: false;
+} & PersonalFabricMutableDataDeleteResult);
+interface GuardianDesktopExecutionActionRequest {
+    action_id: string;
+    app_id: string;
+    action_type: string;
+    target_ref: string;
+    payload_hash: `sha256:${string}`;
+}
+interface GuardianDesktopExecutionPlan {
+    plan_id: string;
+    action_id: string;
+    action_type: string;
+    confirmation_receipt_id: string;
+    action_payload_hash: `sha256:${string}`;
+    execution_surface: string;
+    action_executable_by_mcp: boolean;
+    requires_desktop_confirmation: boolean;
+    plan_hash: `sha256:${string}`;
+    expires_at: string;
+}
+interface GuardianDesktopExecutionInput {
+    actionRequest: GuardianDesktopExecutionActionRequest;
+    executionPlan: GuardianDesktopExecutionPlan;
+}
+export declare function runGuardianCli(argv: readonly string[], options?: GuardianCliOptions): Promise<number>;
+export declare function resolveGuardianHome(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): string;
+export declare function installGuardian(flags: ReadonlyMap<string, string | boolean>, options?: GuardianCliOptions): Promise<string>;
+export declare function doctorGuardian(flags: ReadonlyMap<string, string | boolean>, options?: GuardianCliOptions): Promise<string>;
+export declare function buildGuardianProductionReadinessStatus(home: string, profile: GuardianProfile | undefined, env?: NodeJS.ProcessEnv | undefined): Promise<GuardianProductionReadinessStatus>;
+export declare function requestGuardianDaemonStop(request: GuardianDaemonStopRequest): Promise<GuardianDaemonStopResult>;
+export declare function requestGuardianDaemonHealth(request: GuardianDaemonHealthRequest): Promise<GuardianDaemonHealthResult>;
+export declare function startGuardianDetachedDaemonProcess(request: GuardianDetachedDaemonStartRequest, entrypoint: string, env?: NodeJS.ProcessEnv): Promise<GuardianDetachedDaemonStartResult>;
+export declare function buildGuardianServiceSupervisionStatus(home: string): Promise<GuardianServiceSupervisionStatus>;
+export declare function buildGuardianOsKeyStorageStatus(home: string): Promise<GuardianOsKeyStorageStatus>;
+export declare function updateGuardianPolicyPackSelection(home: string, profile: GuardianProfile, action: GuardianPolicyPackAction, policyPackId: string): Promise<GuardianPolicyPackControlResult>;
+export declare function updateGuardianPromptCoachMode(home: string, profile: GuardianProfile, mode: GuardianPromptCoachMode): Promise<GuardianPreferenceControlResult>;
+export declare function updateGuardianLearningGraph(home: string, profile: GuardianProfile, enabled: boolean): Promise<GuardianPreferenceControlResult>;
+export declare function updateGuardianPostureProfileSelection(home: string, profile: GuardianProfile, selected: GuardianPostureProfileId): Promise<GuardianPostureProfileControlResult>;
+export declare function updateGuardianPrivacyMode(home: string, profile: GuardianProfile): Promise<GuardianPrivacyControlResult>;
+export declare function updateGuardianAppPermission(home: string, profile: GuardianProfile, action: GuardianAppPermissionAction, appId: string): Promise<GuardianAppPermissionControlResult>;
+export declare function updateGuardianProviderPermission(home: string, profile: GuardianProfile, action: GuardianAppPermissionAction, providerId: GuardianProviderId): Promise<GuardianAppPermissionControlResult>;
+export declare function updateGuardianSourcePermission(home: string, profile: GuardianProfile, action: GuardianAppPermissionAction, sourceType: GuardianSourceTypeId): Promise<GuardianAppPermissionControlResult>;
+export declare function normalizeGuardianProfile(profile: GuardianProfile): GuardianProfile;
+export declare function exportGuardianDataSnapshot(home: string, outputPath: string, env?: NodeJS.ProcessEnv | undefined): Promise<GuardianDataLifecycleResult>;
+export declare function backupGuardianDataStore(home: string, outputPath: string, env?: NodeJS.ProcessEnv | undefined): Promise<GuardianDataLifecycleResult>;
+export declare function restoreGuardianDataSnapshot(home: string, inputPath: string, env?: NodeJS.ProcessEnv | undefined): Promise<GuardianDataLifecycleResult>;
+export declare function deleteGuardianMutableData(home: string, env?: NodeJS.ProcessEnv | undefined): Promise<GuardianDataLifecycleResult>;
+export declare function executeGuardianDesktopActionPlan(home: string, profile: GuardianProfile, input: GuardianDesktopExecutionInput, options?: GuardianCliOptions): Promise<{
+    schema_version: 'contextecf/project-guardian-desktop-execution/v1';
+    success: true;
+    actionExecuted: true;
+    actionAuthorized: true;
+    executionMode: 'desktop_adapter_executed';
+    adapter: typeof GUARDIAN_DESKTOP_URL_OPEN_ADAPTER_ID;
+    adapterVersion: typeof GUARDIAN_DESKTOP_URL_OPEN_ADAPTER_VERSION;
+    adapterProofSchemaVersion: typeof GUARDIAN_DESKTOP_URL_OPEN_ADAPTER_PROOF_SCHEMA_VERSION;
+    adapterCapability: 'browser_url_open';
+    appId: string;
+    actionType: 'open';
+    actionId: string;
+    planId: string;
+    planHash: `sha256:${string}`;
+    targetRefHash: `sha256:${string}`;
+    receiptId: string;
+    receiptHash: string;
+    rawContentIncluded: false;
+    tokenPrinted: false;
+    eventChain: Awaited<ReturnType<SQLitePersonalFabricStore['verifyEventChain']>>;
+}>;
+export declare function buildGuardianReleaseEvidenceStatus(home: string): Promise<GuardianReleaseEvidenceStatus>;
+export declare function buildGuardianDoctorStatus(home: string, profile: GuardianProfile | undefined, env?: NodeJS.ProcessEnv | undefined): Promise<GuardianDoctorStatus>;
+export {};

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@contextecf/guardian-cli",
+  "version": "0.1.0",
+  "description": "Project Guardian local-first Personal Context Fabric CLI",
+  "type": "module",
+  "license": "UNLICENSED",
+  "main": "dist/packages/guardian-cli/src/index.js",
+  "types": "dist/packages/guardian-cli/src/index.d.ts",
+  "engines": {
+    "node": ">=22"
+  },
+  "files": [
+    "dist/packages/guardian-cli/src/bin.d.ts",
+    "dist/packages/guardian-cli/src/index.d.ts",
+    "dist/packages/guardian-cli/src/runtime.d.ts",
+    "dist/packages/guardian-cli/src/bin.js",
+    "dist/packages/guardian-cli/src/index.js",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "import": "./dist/packages/guardian-cli/src/index.js",
+      "types": "./dist/packages/guardian-cli/src/index.d.ts"
+    }
+  },
+  "bin": {
+    "guardian": "./dist/packages/guardian-cli/src/bin.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && node scripts/bundle-npm-entrypoints.mjs && node scripts/mark-bin-executable.mjs",
+    "dev": "tsx src/index.ts",
+    "pack:dry-run": "npm pack --dry-run",
+    "prepack": "npm run build",
+    "release:doctor": "npm run build && npm pack --dry-run",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "ai-governance",
+    "context-fabric",
+    "guardian",
+    "local-first",
+    "mcp"
+  ],
+  "dependencies": {
+    "better-sqlite3": "^13.0.1",
+    "better-sqlite3-multiple-ciphers": "^12.11.1"
+  },
+  "devDependencies": {
+    "@contextecf/guardian-mcp-server": "*",
+    "@contextecf/personal-fabric-contracts": "*",
+    "@contextecf/personal-fabric-runtime": "*",
+    "@contextecf/personal-fabric-store": "*",
+    "esbuild": "^0.25.0",
+    "vitest": "^4.1.8"
+  }
+}