@pdpp/local-collector 0.4.0 → 0.6.0

package/README.md

@@ -32,6 +32,13 @@ PDPP_CONNECTION_ID=<source_instance_id> \
 npx -y @pdpp/local-collector run \
   --base-url https://<reference-host> \
   --connector claude_code
+
+# Preview host-local recovery for a stalled collector lane. This loads the
+# enrolled local profile for the source instance and changes nothing.
+npx -y @pdpp/local-collector recover --source-instance-id <source_instance_id>
+
+# Apply recovery: requeue failed uploads when present, then run the collector once.
+npx -y @pdpp/local-collector recover --source-instance-id <source_instance_id> --apply
 ```
 
 The collector sends `X-PDPP-Collector-Protocol` on enrollment and every

package/dist/local-collector/bin/pdpp-local-collector.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
-import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
 import { basename, dirname, extname, join, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { ALLOW_CUSTOM_COMMAND_ENV, CollectorCustomCommandRefusedError, CollectorUsageError, } from "../src/errors.js";
@@ -8,6 +9,7 @@ const COVERAGE_DIAGNOSTICS_STREAM = "coverage_diagnostics";
 const DEFAULT_QUEUE_PATH = join(dirname(fileURLToPath(import.meta.url)), "..", ".pdpp-data", "collector-runner-queue.json");
 const LOCAL_COLLECTOR_PACKAGE_NAME = "@pdpp/local-collector";
 const LOCAL_COLLECTOR_PACKAGE_VERSION_FALLBACK = "0.0.0";
+const LOCAL_COLLECTOR_PROFILE_DIR_ENV = "PDPP_LOCAL_COLLECTOR_PROFILE_DIR";
 const LOCAL_COLLECTOR_PLACEHOLDER_VERSION = "0.0.0";
 const REPO_ONLY_PACKAGE_SIBLINGS = ["src", "bin", "test", "scripts", "tsconfig.build.json"];
 function resolveLocalCollectorManifest(startUrl) {
@@ -96,18 +98,27 @@ Subcommands:
   status                          Print local durable outbox health as JSON.
           [--queue <path>]
           [--connection-id <id>]
+          [--source-instance-id <id>]
   doctor                          Print local durable outbox operator diagnostics as JSON.
           [--queue <path>]
           [--connection-id <id>]
+          [--source-instance-id <id>]
   retry-dead-letters              Requeue local dead-letter outbox rows.
           [--queue <path>]
           [--connection-id <id>]
+          [--source-instance-id <id>]
           [--kind record_batch|checkpoint|gap|blob_upload]
           [--limit <n>]
           [--apply]                Dry-run by default; --apply mutates after a DB backup.
+  recover                         Resolve the enrolled local profile, recover stalled outbox work,
+                                   and run the collector once.
+          --source-instance-id <id>
+          [--profile <name>]        Optional profile name under the collector profile dir.
+          [--apply]                Dry-run by default; --apply requeues and runs.
   prune-sent                      Delete sent (succeeded) outbox rows to reclaim disk space.
           [--queue <path>]
           [--connection-id <id>]
+          [--source-instance-id <id>]
           [--older-than-days <n>]  Delete sent rows older than N days (default: 30).
           [--keep-count <n>]       Keep at most N most-recent sent rows per connection.
           [--apply]                Dry-run by default; --apply mutates after a DB backup.
@@ -126,6 +137,7 @@ Subcommands:
           --device-id <id>
           --device-token <token>
           --connection-id <id>
+          [--source-instance-id <id>]
           [--streams a,b,c]
           [--backfill-streams attachments]
           [--run-id <id>]
@@ -164,6 +176,11 @@ async function main() {
         process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
         return;
     }
+    if (options.command === "recover") {
+        const result = await recoverLocalCollector(options);
+        process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+        return;
+    }
     if (options.command === "prune-sent") {
         const result = pruneSentOutboxRows(options);
         process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
@@ -189,14 +206,18 @@ async function main() {
         process.stdout.write(`${JSON.stringify(response, null, 2)}\n`);
         return;
     }
+    const result = await runCollectorOnce(options);
+    process.stdout.write(`${JSON.stringify(summarizeRunResultForCli(result), null, 2)}\n`);
+}
+async function runCollectorOnce(options) {
     if (!(options.deviceId && options.deviceToken && options.sourceInstanceId)) {
-        throw new CollectorUsageError("run requires --device-id <id>, --device-token <token>, and --connection-id <id>");
+        throw new CollectorUsageError("run requires --device-id <id>, --device-token <token>, and --connection-id/--source-instance-id <id>");
     }
     if (!options.connector) {
         throw new CollectorUsageError("run requires --connector <connector-id>");
     }
     const spec = buildConnectorSpec(options);
-    const result = await runCollectorConnector({
+    return runCollectorConnector({
         baseUrl: options.baseUrl,
         connector: spec,
         deviceId: options.deviceId,
@@ -205,7 +226,6 @@ async function main() {
         ...(options.runId ? { runId: options.runId } : {}),
         sourceInstanceId: options.sourceInstanceId,
     });
-    process.stdout.write(`${JSON.stringify(summarizeRunResultForCli(result), null, 2)}\n`);
 }
 export function summarizeRunResultForCli(result) {
     const summary = result.outboxSummary;
@@ -251,7 +271,7 @@ function runDrainNote(result, summary, drained) {
         parts.push(`${summary.leased} leased (in flight)`);
     }
     if (summary.deadLetter > 0) {
-        parts.push(`${summary.deadLetter} dead-letter (run \`retry-dead-letters\` then re-run)`);
+        parts.push(`${summary.deadLetter} dead-letter (run \`recover --source-instance-id <id> --apply\`)`);
     }
     const scanNote = result.scanBudgetExceeded
         ? " The connector was stopped by the per-run enqueue budget, so more source work likely remains; re-run to continue."
@@ -362,9 +382,9 @@ export function buildLocalOutboxDoctor(status, errorSummary) {
             ? ` Most common cause: ${topClass.error_class} (${topClass.count} row(s)).`
             : "";
         remediation.push(`${status.outbox.counts.dead_letter} dead-letter row(s) need recovery.${causeHint} ` +
-            "Preview with `pdpp-local-collector retry-dead-letters`, then requeue with " +
-            "`pdpp-local-collector retry-dead-letters --apply` (backs up the DB first), " +
-            "then re-run the collector to drain the requeued rows.");
+            "Preview with `pdpp-local-collector recover --source-instance-id <id>`, then apply with " +
+            "`pdpp-local-collector recover --source-instance-id <id> --apply`. The apply step backs up the DB, " +
+            "prepares failed uploads for retry when present, and runs the collector once.");
     }
     if (checks.expired_leases === "warn") {
         remediation.push(`${status.outbox.expired_leases} lease(s) are past expiry — a previous run likely crashed mid-drain. ` +
@@ -440,16 +460,17 @@ export function readLocalOutboxDeadLetterErrorSummary(options) {
 }
 const RETRY_DEAD_LETTERS_NO_MATCH_NOTE = "No dead-letter rows matched. If the dashboard shows this connection as " +
     "blocked/stalled, that is a state-read block, not a dead-letter backlog — " +
-    "there is nothing to requeue. Recovery is to re-run the collector " +
-    "(`pdpp-local-collector run …`), which re-reads prior state and clears the block.";
+    "there is nothing to requeue. Use `pdpp-local-collector recover --source-instance-id <id> --apply` " +
+    "to run the collector through the enrolled local profile and clear the block.";
 function retryDeadLettersMatchNote(matched, dryRun) {
     if (matched === 0) {
         return RETRY_DEAD_LETTERS_NO_MATCH_NOTE;
     }
     const requeued = dryRun
-        ? `${matched} dead-letter row(s) would be requeued (dry run). Re-run with --apply to requeue (backs up the DB first), `
+        ? `${matched} dead-letter row(s) would be requeued (dry run). `
         : `${matched} dead-letter row(s) matched and were requeued to pending. `;
-    return `${requeued}then re-run the collector (\`pdpp-local-collector run …\`) to drain them — requeue moves rows to pending, it does not ingest.`;
+    return (`${requeued}Use \`pdpp-local-collector recover --source-instance-id <id> --apply\` for the dashboard recovery path. ` +
+        "This low-level command only moves rows to pending; it does not ingest.");
 }
 export function retryLocalOutboxDeadLetters(options) {
     const dbPath = resolveOutboxPath(options);
@@ -505,6 +526,205 @@ export function retryLocalOutboxDeadLetters(options) {
         outbox.close();
     }
 }
+function defaultCollectorProfileDir() {
+    const configHome = process.env.XDG_CONFIG_HOME?.trim() || join(homedir(), ".config");
+    return join(configHome, "pdpp", "collectors");
+}
+export function parseCollectorProfileEnv(contents) {
+    const env = {};
+    for (const rawLine of contents.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith("#")) {
+            continue;
+        }
+        const assignment = line.startsWith("export ") ? line.slice("export ".length).trim() : line;
+        const eq = assignment.indexOf("=");
+        if (eq <= 0) {
+            continue;
+        }
+        const key = assignment.slice(0, eq).trim();
+        const rawValue = assignment.slice(eq + 1).trim();
+        if (!/^[A-Z0-9_]+$/.test(key)) {
+            continue;
+        }
+        env[key] = unquoteProfileEnvValue(rawValue);
+    }
+    return env;
+}
+function unquoteProfileEnvValue(rawValue) {
+    if (rawValue.length >= 2) {
+        const quote = rawValue[0];
+        if ((quote === '"' || quote === "'") && rawValue.endsWith(quote)) {
+            const inner = rawValue.slice(1, -1);
+            return quote === '"' ? inner.replace(/\\"/g, '"').replace(/\\\\/g, "\\") : inner;
+        }
+    }
+    return rawValue;
+}
+function profileSourceInstanceId(env) {
+    return env.PDPP_SOURCE_INSTANCE_ID?.trim() || env.PDPP_CONNECTION_ID?.trim() || null;
+}
+function safeProfileFileName(name) {
+    const trimmed = name.trim();
+    if (!/^[A-Za-z0-9._-]+$/.test(trimmed)) {
+        throw new CollectorUsageError("--profile must be a simple profile file name");
+    }
+    return trimmed.endsWith(".env") ? trimmed : `${trimmed}.env`;
+}
+export function findLocalCollectorProfiles(input) {
+    const profileDir = input.profileDir?.trim() || process.env[LOCAL_COLLECTOR_PROFILE_DIR_ENV]?.trim() || defaultCollectorProfileDir();
+    const sourceInstanceId = input.sourceInstanceId?.trim() || null;
+    const files = input.profileName
+        ? [safeProfileFileName(input.profileName)]
+        : (() => {
+            try {
+                return readdirSync(profileDir).filter((name) => name.endsWith(".env")).sort();
+            }
+            catch {
+                return [];
+            }
+        })();
+    const matches = [];
+    for (const file of files) {
+        const path = join(profileDir, file);
+        let env;
+        try {
+            env = parseCollectorProfileEnv(readFileSync(path, "utf8"));
+        }
+        catch {
+            continue;
+        }
+        const profileSource = profileSourceInstanceId(env);
+        if (sourceInstanceId && profileSource !== sourceInstanceId) {
+            continue;
+        }
+        matches.push({
+            env,
+            name: file.replace(/\.env$/, ""),
+            path,
+            source_instance_id: profileSource,
+        });
+    }
+    return { matches, profile_dir: profileDir };
+}
+function applyProfileEnv(options, profile) {
+    const env = profile.env;
+    const explicit = options.explicitOptions;
+    const keep = (flag) => explicit?.has(flag) === true;
+    const next = {
+        ...options,
+        baseUrl: keep("--base-url") ? options.baseUrl : env.PDPP_REFERENCE_BASE_URL?.trim() || options.baseUrl,
+        queuePath: keep("--queue") ? options.queuePath : env.PDPP_COLLECTOR_QUEUE?.trim() || options.queuePath,
+    };
+    const sourceInstanceId = profile.source_instance_id ?? options.sourceInstanceId;
+    const connector = keep("--connector") ? options.connector : env.PDPP_COLLECTOR_CONNECTOR?.trim() || options.connector;
+    const deviceId = keep("--device-id") ? options.deviceId : env.PDPP_LOCAL_DEVICE_ID?.trim() || options.deviceId;
+    const deviceToken = keep("--device-token") ? options.deviceToken : env.PDPP_LOCAL_DEVICE_TOKEN?.trim() || options.deviceToken;
+    if (sourceInstanceId) {
+        next.sourceInstanceId = sourceInstanceId;
+    }
+    if (connector) {
+        next.connector = connector;
+    }
+    if (deviceId) {
+        next.deviceId = deviceId;
+    }
+    if (deviceToken) {
+        next.deviceToken = deviceToken;
+    }
+    return next;
+}
+function resolveRecoveryOptions(options) {
+    const sourceInstanceId = options.sourceInstanceId?.trim();
+    if (!sourceInstanceId) {
+        throw new CollectorUsageError("recover requires --source-instance-id <id>");
+    }
+    const lookup = findLocalCollectorProfiles({
+        profileName: options.profile ?? null,
+        sourceInstanceId,
+    });
+    if (lookup.matches.length > 1) {
+        throw new CollectorUsageError(`recover found ${lookup.matches.length} local collector profiles for source_instance_id '${sourceInstanceId}'. ` +
+            "Pass --profile <name> to disambiguate.");
+    }
+    if (lookup.matches.length === 1) {
+        const profile = lookup.matches[0];
+        return {
+            options: applyProfileEnv(options, profile),
+            profileName: profile.name,
+            profileSource: "local_profile",
+        };
+    }
+    const configuredQueue = options.queuePath !== DEFAULT_QUEUE_PATH || Boolean(process.env.PDPP_COLLECTOR_QUEUE?.trim());
+    if (!configuredQueue) {
+        throw new CollectorUsageError(`recover could not find a local collector profile for source_instance_id '${sourceInstanceId}'. ` +
+            "Run this on the collector host after enrollment, pass --profile <name>, or set PDPP_COLLECTOR_QUEUE/--queue explicitly. " +
+            "Refusing to inspect the package default queue because it is often unrelated to the enrolled collector.");
+    }
+    return {
+        options,
+        profileName: null,
+        profileSource: "configured_queue",
+    };
+}
+function hasDeadLetters(status) {
+    return status.outbox.counts.dead_letter > 0;
+}
+function recoverDryRunNote(status) {
+    if (hasDeadLetters(status)) {
+        return (`${status.outbox.counts.dead_letter} failed upload row(s) would be prepared for retry, then the collector would run once. ` +
+            "Dry run only; re-run with --apply to mutate the local outbox and upload.");
+    }
+    return ("No failed upload rows are present for this source. The recovery apply step would run the collector once on this host " +
+        "to refresh state and drain queued work.");
+}
+function recoverAppliedNote(statusBefore, retry) {
+    const retried = retry ? `${retry.requeued} failed upload row(s) were prepared for retry. ` : "";
+    if (hasDeadLetters(statusBefore)) {
+        return `${retried}The collector ran once to upload queued work. Run status again if the dashboard has not refreshed yet.`;
+    }
+    return "The collector ran once to refresh local state and drain queued work.";
+}
+export async function recoverLocalCollector(options) {
+    const resolved = resolveRecoveryOptions(options);
+    const sourceInstanceId = resolved.options.sourceInstanceId;
+    if (!sourceInstanceId) {
+        throw new CollectorUsageError("recover requires --source-instance-id <id>");
+    }
+    const statusBefore = inspectLocalOutboxStatus(resolved.options);
+    const retryPreview = hasDeadLetters(statusBefore) ? retryLocalOutboxDeadLetters({ ...resolved.options, apply: false }) : null;
+    if (!options.apply) {
+        return {
+            applied: false,
+            db: statusBefore.db.path ? { exists: statusBefore.db.exists, path: statusBefore.db.path } : { exists: false, path: "" },
+            dry_run: true,
+            note: recoverDryRunNote(statusBefore),
+            object: "local_collector_recovery",
+            profile: { name: resolved.profileName, source: resolved.profileSource },
+            retry_dead_letters: retryPreview,
+            run: null,
+            source_instance_id: sourceInstanceId,
+            status_after: null,
+            status_before: statusBefore,
+        };
+    }
+    const retryApply = hasDeadLetters(statusBefore) ? retryLocalOutboxDeadLetters({ ...resolved.options, apply: true }) : null;
+    const run = summarizeRunResultForCli(await runCollectorOnce(resolved.options));
+    const statusAfter = inspectLocalOutboxStatus(resolved.options);
+    return {
+        applied: true,
+        db: statusAfter.db.path ? { exists: statusAfter.db.exists, path: statusAfter.db.path } : { exists: false, path: "" },
+        dry_run: false,
+        note: recoverAppliedNote(statusBefore, retryApply),
+        object: "local_collector_recovery",
+        profile: { name: resolved.profileName, source: resolved.profileSource },
+        retry_dead_letters: retryApply,
+        run,
+        source_instance_id: sourceInstanceId,
+        status_after: statusAfter,
+        status_before: statusBefore,
+    };
+}
 function summaryCounts(summary) {
     return {
         dead_letter: summary.deadLetter,
@@ -644,7 +864,7 @@ export function compactOutbox(options) {
                 db: { exists: true, path: dbPath },
                 dry_run: false,
                 note: `Refusing to compact: ${nonSucceeded} non-succeeded (ready/leased/dead-letter) row(s) are still in the outbox. ` +
-                    "Drain the lane first (`pdpp-local-collector run …`, then `retry-dead-letters --apply` for any dead-letter rows), " +
+                    "Drain the lane first (`pdpp-local-collector recover --source-instance-id <id> --apply` for stalled work), " +
                     "or pass --force to compact anyway. VACUUM is lossless — unsent rows are copied, never dropped — but compacting a " +
                     "live lane is refused by default so the reclaim runs on a quiet outbox.",
                 non_succeeded_rows: nonSucceeded,
@@ -739,16 +959,19 @@ export function parseArgs(args) {
         command !== "advertise" &&
         command !== "status" &&
         command !== "doctor" &&
+        command !== "recover" &&
         command !== "retry-dead-letters" &&
         command !== "prune-sent" &&
         command !== "compact") {
-        throw new CollectorUsageError(`usage: pdpp-local-collector <enroll|run|advertise|status|doctor|retry-dead-letters|prune-sent|compact> --base-url <url> [options]`);
+        throw new CollectorUsageError(`usage: pdpp-local-collector <enroll|run|advertise|status|doctor|recover|retry-dead-letters|prune-sent|compact> --base-url <url> [options]`);
     }
     const options = {
         baseUrl: process.env.PDPP_REFERENCE_BASE_URL ?? "http://127.0.0.1:7662",
         command,
         queuePath: process.env.PDPP_COLLECTOR_QUEUE ?? DEFAULT_QUEUE_PATH,
     };
+    const explicitOptions = new Set();
+    options.explicitOptions = explicitOptions;
     if (process.env.PDPP_LOCAL_DEVICE_ID) {
         options.deviceId = process.env.PDPP_LOCAL_DEVICE_ID;
     }
@@ -773,10 +996,12 @@ export function parseArgs(args) {
             throw new CollectorUsageError("missing option");
         }
         if (applyFlagOption(options, arg)) {
+            explicitOptions.add(arg);
             continue;
         }
         const value = rest[index + 1];
         applyOption(options, arg, value);
+        explicitOptions.add(arg);
         index++;
     }
     return options;
@@ -827,14 +1052,17 @@ function applyOption(options, arg, value) {
         "--queue": (next) => {
             options.queuePath = next;
         },
+        "--profile": (next) => {
+            options.profile = next;
+        },
         "--run-id": (next) => {
             options.runId = next;
         },
         "--connection-id": (next) => {
-            options.sourceInstanceId = next;
+            setExplicitSourceInstanceId(options, arg, next);
         },
         "--source-instance-id": (next) => {
-            options.sourceInstanceId = next;
+            setExplicitSourceInstanceId(options, arg, next);
         },
         "--streams": (next) => {
             options.streams = parseCsv(next);
@@ -858,6 +1086,13 @@ function applyOption(options, arg, value) {
     }
     set(value);
 }
+function setExplicitSourceInstanceId(options, arg, value) {
+    const hadExplicitSource = options.explicitOptions?.has("--connection-id") || options.explicitOptions?.has("--source-instance-id");
+    if (hadExplicitSource && options.sourceInstanceId && options.sourceInstanceId !== value) {
+        throw new CollectorUsageError(`${arg} disagrees with the already supplied source identity '${options.sourceInstanceId}'`);
+    }
+    options.sourceInstanceId = value;
+}
 function parseOutboxKind(value) {
     if (value === "record_batch" || value === "checkpoint" || value === "gap" || value === "blob_upload") {
         return value;

package/dist/polyfill-connectors/src/collector-build-info.js

@@ -1,8 +1,8 @@
 const COLLECTOR_BUILD_SOURCE_SENTINEL = "source";
 const COLLECTOR_BUILD_INFO = {
-    builtAt: "2026-06-11T00:01:48.219Z",
-    revision: "5ac4f6d1a3a9",
-    version: "0.4.0",
+    builtAt: "2026-06-17T01:36:27.814Z",
+    revision: "1d3825462d7b",
+    version: "0.6.0",
 };
 function buildAgentVersion(info = COLLECTOR_BUILD_INFO) {
     return `${info.version}+${info.revision}`;

package/dist/polyfill-connectors/src/connector-runtime-protocol.d.ts

@@ -13,6 +13,7 @@ export interface StreamScope {
 }
 export interface StartMessage {
     detail_gaps?: readonly DetailGapStartEntry[];
+    recovery_only?: boolean;
     scope: {
         streams: readonly StreamScope[];
     };
@@ -150,6 +151,22 @@ export interface ProviderBudgetProgress {
     request_count: number;
     retry_tokens_remaining?: number | "unbounded";
 }
+export interface CollectionRateProgress {
+    ceiling_interval_ms: number;
+    ceiling_rate_per_min: number;
+    current_interval_ms: number;
+    effective_rate_per_min: number;
+    last_backoff: {
+        at_interval_ms: number;
+        reason: "retry_after" | "throttle";
+    } | null;
+    object: "collection_rate";
+}
+export interface ProgressExtra {
+    count?: number;
+    stream?: string;
+    total?: number;
+}
 export type EmittedMessage = {
     type: "RECORD";
     stream: string;
@@ -164,8 +181,11 @@ export type EmittedMessage = {
 } | {
     type: "PROGRESS";
     message: string;
+    count?: number;
     stream?: string;
+    total?: number;
     provider_budget?: ProviderBudgetProgress;
+    collection_rate?: CollectionRateProgress;
 } | ({
     type: "ASSISTANCE";
 } & AssistanceRequest) | ({
@@ -176,6 +196,10 @@ export type EmittedMessage = {
     reason: string;
     message: string;
     diagnostics?: unknown;
+    recovery_hint?: string | {
+        action?: string;
+        retryable?: boolean;
+    };
 } | DetailGapMessage | DetailCoverageMessage | DetailGapRecoveredMessage | DetailGapsPageRequestMessage | {
     type: "DONE";
     status: "succeeded" | "failed";

package/dist/polyfill-connectors/src/connector-runtime.js

@@ -255,6 +255,7 @@ export function runConnector(config) {
             emittedAt,
             detailGaps: startMsg.detail_gaps ?? [],
             requestDetailGapPage,
+            recoveryOnly: startMsg.recovery_only === true,
         };
         if (browser) {
             await runInBrowser({

package/dist/polyfill-connectors/src/static-secret-injection.js

@@ -40,6 +40,14 @@ export const STATIC_SECRET_CONNECTOR_REGISTRY = Object.freeze({
             slack_cookie: ["SLACK_COOKIE"],
         },
     }),
+    oura: freezeStaticSecretDescriptor({
+        credentialKind: "personal_access_token",
+        secretEnvVars: ["OURA_PERSONAL_ACCESS_TOKEN"],
+    }),
+    notion: freezeStaticSecretDescriptor({
+        credentialKind: "personal_access_token",
+        secretEnvVars: ["NOTION_API_TOKEN"],
+    }),
     reddit: freezeStaticSecretDescriptor({
         credentialKind: "secret_bundle",
         secretFieldEnvVars: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pdpp/local-collector",
-  "version": "0.4.0",
+  "version": "0.6.0",
   "description": "Publishable local collector runtime for PDPP: filesystem-class connectors (Claude Code, Codex) plus the device-exporter ingest client.",
   "type": "module",
   "private": false,