@indigoai-us/hq-cli 5.345.134 → 5.345.136

package/dist/commands/storage-offload.js

@@ -8,13 +8,18 @@
  *     uploads each blob, verifies size + sha256 + git blob id, then hands only
  *     verified blobs to core `hq-storage.sh strip-large`, which rewrites history
  *     to the pointer text. Working-tree files are never touched.
- *   - Current files (idle big files in the working tree). NOT offloaded yet:
- *     the sync delete planner lives in @indigoai-us/hq-cloud (`computePullPlan`
- *     and the push delete planner in dist/cli/sync.js), so replacing `x.mp4`
- *     with `x.mp4.hqcloud` would still propagate as a remote delete of `x.mp4`.
- *     `--current` reports `{ available: false }` until hq-cloud learns about
- *     placeholders (CURRENT_OFFLOAD_ENABLED). `offloadCurrentFile` is built
- *     and tested but not called.
+ *   - Current files (`--current [paths...]`, idle big files in the working
+ *     tree). Each file goes to the vault that owns its path. A file under
+ *     `companies/<slug>/` is never uploaded: when HQ sync already stored this
+ *     exact version in that company's vault (journal hash + size, and the vault
+ *     object still has the journal's ETag), the file is replaced by a
+ *     placeholder pointing at that object. Otherwise it is skipped with "run
+ *     hq sync first", so sync stays the only writer of company vault keys. Any
+ *     other file points at its personal-vault sync object the same way, or is
+ *     uploaded to the personal vault's `.hq-offload/blobs/`. Current-file
+ *     offload runs only when the installed HQ sync holds every `.hqcloud`
+ *     sibling (hq-cloud CLOUD_PLACEHOLDER_HOLDS_ANY_SIBLING) and skips
+ *     `.hq-offload/`; otherwise it reports "update HQ sync".
  *
  * Fetch also reads placeholders that HQ sync rewrote after a teammate changed
  * the file (`vault: company`, the company vault key, `sha256: unknown`,
@@ -24,9 +29,10 @@
  * which writes the caller's own personal-vault copy to a file outside HQ so
  * it can never sync back.
  *
- * Tenant isolation: bytes only ever go to the caller's personal vault. The
- * personal store refuses a company vault bucket, and nothing here lists or
- * opens company memberships.
+ * Tenant isolation: uploads only ever go to the caller's personal vault, and
+ * the personal store refuses a company vault bucket. A company vault is opened
+ * read-only (HEAD and ETag-pinned GET), and only for a company the caller is
+ * an active member of.
  */
 import * as crypto from "node:crypto";
 import * as fs from "node:fs";
@@ -42,15 +48,12 @@ export const POINTER_HEADER = "HQ-CLOUD-FILE v1";
 export const POINTER_FOOTER = "This file is stored in HQ cloud storage. Open it in HQ, or run the command above to download it.";
 export const DEFAULT_MIN_BYTES = 50 * 1024 * 1024;
 export const DEFAULT_IDLE_DAYS = 14;
-export const CURRENT_BLOCKED_REASON = "Offloading current files is not available yet: HQ sync would treat the replaced file as deleted.";
-/**
- * Gate for `--current`. Stays false until the owner enables current-file
- * offload on top of hq-cloud's cloud-only placeholders (PR #919, 6.18.61).
- */
-export const CURRENT_OFFLOAD_ENABLED = false;
 export const ORPHANED_MESSAGE = "This file was deleted by a teammate. It's no longer in the cloud for your team.";
 const UPDATE_HQ = "update HQ";
 export const UPDATE_SYNC = "update HQ sync";
+/** Reason on company files HQ sync has not stored in the company vault yet. */
+export const RUN_SYNC_FIRST = "run hq sync first";
+const DAY_MS = 86_400_000;
 const PERSONAL_BUCKET_PREFIX = "hq-vault-prs-";
 /** Top-level HQ-root folder that holds offloaded blobs in the personal vault. */
 export const OFFLOAD_TOP_LEVEL = ".hq-offload";
@@ -63,7 +66,7 @@ export const OFFLOAD_TOP_LEVEL = ".hq-offload";
  * @indigoai-us/hq-cloud 6.18.61 (PR #919) lists ".hq-offload" in
  * PERSONAL_VAULT_EXCLUDED_TOP_LEVEL; storage.ts passes that export here. The
  * check stays at runtime so an older bundled HQ sync still reports
- * "update HQ sync". CURRENT_OFFLOAD_ENABLED is a separate owner decision.
+ * "update HQ sync". Current-file offload also needs syncHoldsPlaceholders.
  */
 export function syncExcludesOffload(excludedTopLevel) {
     return Array.isArray(excludedTopLevel) && excludedTopLevel.includes(OFFLOAD_TOP_LEVEL);
@@ -245,6 +248,17 @@ export function s3BlobStore(bucket, s3) {
 }
 export function s3VaultObjectStore(bucket, s3) {
     return {
+        async head(key) {
+            try {
+                const res = (await s3.send(new HeadObjectCommand({ Bucket: bucket, Key: key })));
+                return { size: res.ContentLength ?? -1, etag: normalizeEtag(res.ETag) };
+            }
+            catch (err) {
+                if (isNotFound(err))
+                    return null;
+                throw err;
+            }
+        },
         async download(key, dest, etag) {
             let res;
             try {
@@ -273,6 +287,21 @@ export function s3VaultObjectStore(bucket, s3) {
         },
     };
 }
+/**
+ * `companies/<slug>/<rest>` belongs to that company's vault at key `<rest>`.
+ * Every other path belongs to the personal vault at its HQ-root-relative path.
+ */
+export function resolveOffloadTarget(rel) {
+    const posix = toPosix(rel);
+    const m = /^companies\/([^/]+)\/(.+)$/.exec(posix);
+    if (m)
+        return { vault: "company", slug: m[1], key: m[2] };
+    return { vault: "personal", key: posix };
+}
+/** Whether current-file offload can run with the installed HQ sync. */
+export function currentSyncReady(deps) {
+    return deps.syncExcludesOffload() && deps.syncHoldsPlaceholders?.() === true;
+}
 // ── Core script capability ──────────────────────────────────────────────────
 export function storageScriptPath(hqRoot) {
     return path.join(hqRoot, "core", "scripts", "hq-storage.sh");
@@ -408,16 +437,17 @@ export const durablePlaceholderFs = {
     },
 };
 /**
- * Offload one current file: upload and verify, write `x.hqcloud` (fsynced),
- * and only then remove `x`. With the placeholder written first, a sync
- * watcher never sees `x` missing without its placeholder, which it would
- * push as a delete.
- *
- * Not called while CURRENT_OFFLOAD_ENABLED is false.
+ * Offload one personal-scope current file by upload: upload and verify,
+ * write `x.hqcloud` (fsynced), and only then remove `x`. With the placeholder
+ * written first, a sync watcher never sees `x` missing without its
+ * placeholder. Company files never take this path (see pointCurrentFileAtVault).
  */
 export async function offloadCurrentFile(rel, store, deps, fsOps = durablePlaceholderFs) {
     if (store.vault !== "personal")
         throw new Error("Offload only writes to your personal vault.");
+    if (resolveOffloadTarget(rel).vault === "company") {
+        throw new Error(`'${rel}' is a company file. Company files are never uploaded to your personal vault.`);
+    }
     assertRestorable(rel);
     const abs = containedPath(deps.hqRoot, rel);
     const before = await fs.promises.stat(abs);
@@ -449,23 +479,251 @@ export async function offloadCurrentFile(rel, store, deps, fsOps = durablePlaceh
     await fsOps.removeOriginal(abs);
     return { path: toPosix(rel), bytes: digest.size };
 }
+/**
+ * Point one current file at the vault object HQ sync stored for it: confirm
+ * the object still has the recorded ETag and size, write `x.hqcloud`
+ * (fsynced), and only then remove `x`. Nothing is uploaded.
+ */
+async function pointCurrentFileAtVault(file, vault, deps, fsOps) {
+    const { plan, target, stat: before, digest, record } = file;
+    if (!before || !digest || !record?.remoteEtag)
+        throw new Error(`'${plan.path}' has no synced version.`);
+    const abs = containedPath(deps.hqRoot, plan.path);
+    const head = await vault.head(target.key);
+    if (!head || head.etag !== normalizeEtag(record.remoteEtag) || head.size !== digest.size) {
+        throw new Error(`The cloud copy of '${plan.path}' changed. Nothing was replaced; ${RUN_SYNC_FIRST}.`);
+    }
+    const unchanged = async () => {
+        const st = await fs.promises.stat(abs);
+        return st.size === before.size && st.mtimeMs === before.mtimeMs;
+    };
+    const changed = new Error(`'${plan.path}' changed while offloading. Nothing was replaced.`);
+    if (!(await unchanged()))
+        throw changed;
+    const placeholder = `${abs}${PLACEHOLDER_SUFFIX}`;
+    await fsOps.writePlaceholder(placeholder, renderPointer({
+        path: plan.path,
+        size: digest.size,
+        sha256: digest.sha256,
+        vault: target.vault,
+        key: target.key,
+        offloadedAt: deps.now().toISOString().replace(/\.\d{3}Z$/, "Z"),
+        remoteEtag: head.etag,
+    }));
+    if (!(await unchanged())) {
+        await fs.promises.rm(placeholder, { force: true });
+        throw changed;
+    }
+    await fsOps.removeOriginal(abs);
+}
+/** Whether a working-tree path is never a current-offload candidate. */
+function skippedByName(rel) {
+    const parts = rel.split("/");
+    const name = parts[parts.length - 1];
+    return (parts[0] === OFFLOAD_TOP_LEVEL ||
+        parts.includes(".git") ||
+        (parts[0] === ".claude" && parts[1] === "hooks") ||
+        name.endsWith(PLACEHOLDER_SUFFIX) ||
+        name.endsWith(".hqcloud-download"));
+}
+/**
+ * Regular files at or under each path argument, HQ-root-relative and sorted.
+ * Symlinks are not followed, and a path outside HQ throws.
+ */
+function walkCurrentPaths(hqRoot, args) {
+    const realRoot = fs.realpathSync(path.resolve(hqRoot));
+    const out = [];
+    const seen = new Set();
+    const visit = (abs) => {
+        const rel = toPosix(path.relative(realRoot, abs));
+        if (rel === "" ? false : skippedByName(rel))
+            return;
+        const st = fs.lstatSync(abs);
+        if (st.isSymbolicLink())
+            return;
+        if (st.isDirectory()) {
+            for (const name of fs.readdirSync(abs).sort())
+                visit(path.join(abs, name));
+            return;
+        }
+        if (st.isFile() && !seen.has(rel)) {
+            seen.add(rel);
+            out.push(rel);
+        }
+    };
+    for (const arg of args) {
+        const lexical = path.resolve(realRoot, arg);
+        const abs = containedPath(hqRoot, arg);
+        if (!fs.existsSync(abs))
+            throw new Error(`'${arg}' does not exist in HQ.`);
+        if (fs.lstatSync(lexical).isSymbolicLink())
+            continue;
+        visit(abs);
+    }
+    return out;
+}
+/**
+ * Decide what `--current` does with each candidate. Read-only: stats and
+ * hashes local files, reads sync records and HEADs vault objects.
+ */
+async function planCurrentFiles(rels, opts, deps, openVault) {
+    let active;
+    const planned = [];
+    const now = deps.now().getTime();
+    for (const rel of rels) {
+        if (skippedByName(rel))
+            continue;
+        const abs = containedPath(deps.hqRoot, rel);
+        let st;
+        try {
+            st = fs.lstatSync(abs);
+        }
+        catch (err) {
+            if (err.code === "ENOENT")
+                continue;
+            throw err;
+        }
+        if (!st.isFile() || fs.existsSync(`${abs}${PLACEHOLDER_SUFFIX}`))
+            continue;
+        const idle = Math.max(0, Math.floor((now - st.mtimeMs) / DAY_MS));
+        if (st.size < opts.minBytes || idle < opts.idleDays)
+            continue;
+        const target = resolveOffloadTarget(rel);
+        const plan = {
+            path: rel,
+            bytes: st.size,
+            idle_days: idle,
+            vault: target.vault,
+            synced: false,
+            action: target.vault === "company" ? "skip" : "upload",
+        };
+        if (target.vault === "company") {
+            plan.company = target.slug;
+            active ??= deps.activeCompanySlugs ? await deps.activeCompanySlugs() : [];
+            if (!active.includes(target.slug)) {
+                plan.reason = `You are not an active member of '${target.slug}'.`;
+                planned.push({ plan, target });
+                continue;
+            }
+        }
+        const record = deps.syncRecord ? await deps.syncRecord(target) : null;
+        let digest;
+        if (record?.remoteEtag && record.hash && record.size === st.size) {
+            digest = await digestFile(abs);
+            if (digest.sha256 === record.hash.toLowerCase()) {
+                const head = await (await openVault(target)).head(target.key);
+                plan.synced = head !== null && head.etag === normalizeEtag(record.remoteEtag) && head.size === st.size;
+            }
+        }
+        if (plan.synced)
+            plan.action = "point-at-vault";
+        else if (target.vault === "company")
+            plan.reason = RUN_SYNC_FIRST;
+        planned.push({ plan, target, stat: st, digest, record: record ?? undefined });
+    }
+    return planned;
+}
+/** `--current`: plan, confirm, then offload each file to the vault that owns it. */
+async function runCurrent(opts, deps, result) {
+    const current = result.current;
+    if (!currentSyncReady(deps)) {
+        current.available = false;
+        current.reason = UPDATE_SYNC;
+        return "ok";
+    }
+    let rels;
+    if (opts.paths && opts.paths.length > 0) {
+        rels = walkCurrentPaths(deps.hqRoot, opts.paths);
+    }
+    else {
+        const large = await getLarge(deps, opts.minBytes);
+        if (!large.available) {
+            current.available = false;
+            current.reason = large.reason;
+            return "ok";
+        }
+        rels = large.current.map((f) => toPosix(f.path));
+    }
+    current.available = true;
+    const vaults = new Map();
+    const openVault = (t) => {
+        if (!deps.openVaultObjects)
+            throw new Error("This HQ build cannot read files stored by HQ sync.");
+        const id = t.vault === "company" ? `company:${t.slug}` : "personal";
+        let v = vaults.get(id);
+        if (!v) {
+            v = deps.openVaultObjects(t.vault === "company" ? { vault: "company", slug: t.slug } : { vault: "personal" });
+            vaults.set(id, v);
+        }
+        return v;
+    };
+    const planned = await planCurrentFiles(rels, opts, deps, openVault);
+    current.files = planned.map((p) => p.plan);
+    const unsynced = planned.filter((p) => p.plan.reason === RUN_SYNC_FIRST).map((p) => p.plan.path);
+    if (unsynced.length > 0) {
+        current.unsynced = unsynced;
+        current.message =
+            `${unsynced.length} company file(s) are not in the company vault yet, so they were left as they are. ` +
+                `To offload them, ${RUN_SYNC_FIRST}, then run offload again: ${unsynced.join(", ")}`;
+    }
+    const todo = planned.filter((p) => p.plan.action !== "skip");
+    if (opts.dryRun || todo.length === 0)
+        return "ok";
+    if (!opts.yes) {
+        const ok = await deps.confirm(`Replace ${todo.length} current file(s) with links to their HQ cloud copies and remove the local copies?`);
+        if (!ok) {
+            deps.log("Aborted - nothing was uploaded or changed.");
+            return "aborted";
+        }
+    }
+    const fsOps = deps.placeholderFs ?? durablePlaceholderFs;
+    let personal;
+    for (const file of todo) {
+        const { plan } = file;
+        try {
+            if (plan.action === "point-at-vault") {
+                await pointCurrentFileAtVault(file, await openVault(file.target), deps, fsOps);
+            }
+            else {
+                personal ??= await deps.openPersonal();
+                await offloadCurrentFile(plan.path, personal, deps, fsOps);
+            }
+            const done = {
+                path: plan.path,
+                bytes: plan.bytes,
+                vault: plan.vault,
+                action: plan.action === "point-at-vault" ? "point-at-vault" : "upload",
+            };
+            if (plan.company)
+                done.company = plan.company;
+            current.offloaded.push(done);
+            current.freed_bytes += plan.bytes;
+        }
+        catch (err) {
+            result.errors.push(`${plan.path}: ${err.message}`);
+        }
+    }
+    return "ok";
+}
 export async function runOffload(opts, deps) {
-    const both = !opts.history && !opts.current;
-    const doHistory = both || opts.history;
-    const doCurrent = both || opts.current;
+    // Current files are offloaded only on request; a bare run touches history only.
+    const doHistory = opts.history || !opts.current;
+    const doCurrent = opts.current;
     const result = {
         history: { uploaded: 0, bytes: 0, freed_bytes: 0 },
         current: { offloaded: [], freed_bytes: 0 },
         errors: [],
         dry_run: opts.dryRun,
     };
-    if (doCurrent) {
-        result.current.available = false;
-        result.current.reason = CURRENT_BLOCKED_REASON;
-    }
+    if (!doCurrent)
+        result.current.skipped = true;
+    if (doCurrent && (await runCurrent(opts, deps, result)) === "aborted")
+        return undefined;
     const script = storageScriptPath(deps.hqRoot);
-    if (!doHistory)
+    if (!doHistory) {
+        result.history.skipped = true;
         return result;
+    }
     if (!deps.syncExcludesOffload()) {
         result.history.available = false;
         result.history.reason = UPDATE_SYNC;
@@ -843,8 +1101,6 @@ async function fetchGitBlob(sha, out, deps) {
 }
 /** Current-file offload availability, shared by status and its error fallback. */
 export function currentAvailability(syncReady) {
-    if (!CURRENT_OFFLOAD_ENABLED)
-        return { current_available: false, current_reason: CURRENT_BLOCKED_REASON };
     if (!syncReady)
         return { current_available: false, current_reason: UPDATE_SYNC };
     return { current_available: true };
@@ -854,7 +1110,7 @@ export async function getOffloadStatus(deps, opts) {
         history_candidates: { count: 0, bytes: 0 },
         current_candidates: { count: 0, bytes: 0 },
         placeholders: { count: 0, bytes: 0 },
-        ...currentAvailability(deps.syncExcludesOffload()),
+        ...currentAvailability(currentSyncReady(deps)),
     };
     for (const rel of await deps.listPlaceholders()) {
         const pointer = readPointerFile(containedPath(deps.hqRoot, rel));

package/dist/commands/storage.js

@@ -41,6 +41,7 @@ import { execFile } from "node:child_process";
 import { dropExpiredBackups, reclaimFields, reclaimWindowHours, runCoreScript, } from "./storage-core.js";
 import { S3Client, ListObjectVersionsCommand, DeleteObjectsCommand, } from "@aws-sdk/client-s3";
 import { PERSONAL_VAULT_EXCLUDED_TOP_LEVEL, VaultClient } from "@indigoai-us/hq-cloud";
+import * as hqCloud from "@indigoai-us/hq-cloud";
 import { buildVaultConfig, DEFAULT_COGNITO } from "../utils/cognito-session.js";
 import { resolveVaultCredential } from "../utils/resolve-vault-credential.js";
 import { vaultApiFetch } from "../utils/vault-api.js";
@@ -775,7 +776,10 @@ export function formatOffloadStatus(o) {
 export function formatOffload(r) {
     const lines = [];
     const h = r.history;
-    if (h.refused) {
+    if (h.skipped) {
+        // History was not part of this run.
+    }
+    else if (h.refused) {
         // Core's and the CLI's refusal messages may already say nothing changed;
         // add that sentence only when the message lacks it.
         const msg = (h.message ?? "").trim();
@@ -797,7 +801,7 @@ export function formatOffload(r) {
     else {
         lines.push(`History: uploaded ${h.uploaded} old version(s), ${formatBytes(h.bytes)}; freed ${formatBytes(h.freed_bytes)}`);
     }
-    if (h.available !== false) {
+    if (!h.skipped && h.available !== false) {
         const pending = reclaimLine(h);
         if (pending)
             lines.push(`  ${pending}`);
@@ -806,16 +810,44 @@ export function formatOffload(r) {
             lines.push(`  ${h.held_by_worktrees.count} more old version(s) (${formatBytes(h.held_by_worktrees.bytes)}) stay: ${names} still uses this history.`);
         }
     }
-    if (r.current.available === false) {
-        lines.push(`Current files: not available - ${r.current.reason ?? "unknown"}`);
+    const c = r.current;
+    if (c.skipped) {
+        // Current files were not part of this run.
+    }
+    else if (c.available === false) {
+        lines.push(`Current files: not available - ${c.reason ?? "unknown"}`);
     }
     else {
-        lines.push(`Current files: moved ${r.current.offloaded.length}, freed ${formatBytes(r.current.freed_bytes)}`);
+        const files = c.files ?? [];
+        if (r.dry_run) {
+            const todo = files.filter((f) => f.action !== "skip");
+            lines.push(`Current files: would offload ${todo.length} of ${files.length}, ${formatBytes(todo.reduce((n, f) => n + f.bytes, 0))}`);
+        }
+        else {
+            lines.push(`Current files: moved ${c.offloaded.length}, freed ${formatBytes(c.freed_bytes)}`);
+        }
+        for (const f of files)
+            lines.push(`  ${formatCurrentFile(f)}`);
+        if (c.message)
+            lines.push(`  ${c.message}`);
     }
     for (const e of r.errors)
         lines.push(chalk.red(`  ${e}`));
     return lines.join("\n");
 }
+const CURRENT_ACTION_LABEL = {
+    "point-at-vault": "point at vault",
+    upload: "upload",
+    skip: "skip",
+};
+/** One `--current` plan line: path, size, owning vault, sync state, action. */
+function formatCurrentFile(f) {
+    const vault = f.vault === "company" ? `company ${f.company ?? "?"}` : "personal vault";
+    const parts = [f.path, formatBytes(f.bytes), vault, f.synced ? "synced" : "not synced", CURRENT_ACTION_LABEL[f.action]];
+    if (f.action === "skip" && f.reason)
+        parts.push(`(${f.reason})`);
+    return parts.join("  ");
+}
 /** One line on when backed-up space comes back, or nothing. */
 export function reclaimLine(r) {
     const pending = num(r.pending_reclaim_bytes);
@@ -993,6 +1025,7 @@ async function buildOffloadDeps() {
         }
         return companiesFromMemberships(await res.json());
     };
+    const journals = new Map();
     return {
         hqRoot,
         now: () => new Date(),
@@ -1008,6 +1041,25 @@ async function buildOffloadDeps() {
             return personalS3Store({ bucket, region: DEFAULT_COGNITO.region, credentials });
         },
         activeCompanySlugs: async () => (await activeCompanies()).map((c) => c.slug),
+        // Current-file offload replaces a file with a placeholder only when the
+        // installed sync engine holds every `.hqcloud` sibling (no delete, no
+        // download over it). Older engines lack the flag, so this stays false.
+        syncHoldsPlaceholders: () => hqCloud.CLOUD_PLACEHOLDER_HOLDS_ANY_SIBLING === true,
+        // What HQ sync last stored for a file, read from its local journal.
+        // Company journal keys are relative to the company folder; personal keys
+        // are relative to the HQ root. Read-only: offload never writes a journal.
+        syncRecord: async (target) => {
+            const slug = target.vault === "company" ? target.slug : hqCloud.PERSONAL_VAULT_JOURNAL_SLUG;
+            let journal = journals.get(slug);
+            if (!journal) {
+                journal = hqCloud.readJournal(slug);
+                journals.set(slug, journal);
+            }
+            const entry = hqCloud.getEntry(journal, target.key);
+            if (!entry || hqCloud.isTombstone(entry))
+                return null;
+            return { hash: entry.hash, size: entry.size, remoteEtag: entry.remoteEtag };
+        },
         // Read-only, for placeholders that HQ sync rewrote. Company credentials
         // come from the existing membership-scoped /sts/vend path.
         openVaultObjects: async (target) => {
@@ -1169,11 +1221,11 @@ export function registerStorageCommand(program) {
     });
     storage
         .command("offload")
-        .description("Move big files to your personal HQ cloud storage and leave links behind (old versions in history; idle current files)")
+        .description("Move big files to HQ cloud storage and leave links behind (old versions in history; with --current, idle working files to the vault that owns them)")
         .option("--min-size <size>", "Only files at least this big, e.g. 50MB (env HQ_OFFLOAD_MIN_BYTES)")
         .option("--idle-days <days>", "Current files must be untouched this many days", String(DEFAULT_IDLE_DAYS))
         .option("--history", "Only old versions in local autosave history")
-        .option("--current", "Only idle files in the working tree")
+        .option("--current [paths...]", "Idle working files instead of history; optional HQ paths limit it to those files or folders")
         .option("--dry-run", "Show what would move without uploading or changing anything")
         .option("--yes", "Skip the confirmation prompt")
         .option("--json", "Print JSON")
@@ -1188,6 +1240,7 @@ export function registerStorageCommand(program) {
                 idleDays,
                 history: Boolean(opts.history),
                 current: Boolean(opts.current),
+                paths: Array.isArray(opts.current) ? opts.current : undefined,
                 dryRun: Boolean(opts.dryRun),
                 yes: Boolean(opts.yes),
             }, await buildOffloadDeps());