@reticlehq/server 3.5.0 → 3.7.0

package/dist/memory/project/dir/reticle-dir.d.ts

@@ -17,8 +17,6 @@ export interface ReticleDirPaths {
     impact: string;
     /**.../.reticle/intent.json — the LEGACY single ledger, read until the first write migrates it into .reticle/intent/ */
     intent: string;
-    /**.../.reticle/fill-values.json (what a drive types into each labelled field — git-checked) */
-    fillValues: string;
     /**.../.reticle/visual (PNG baselines + diffs) */
     visual: string;
     /**.../.reticle/runs (verification-run artifacts) */
@@ -37,8 +35,21 @@ export interface ReticleDirPaths {
     coverage: string;
     /**.../.reticle/assertion-tiers.json (last-passing assertion tiers; anti-reward-hacking baseline) */
     tiers: string;
+    /**.../.reticle/request.json (the user's latest request, relayed by the agent, classified) */
+    request: string;
+    /** .reticle/plans/ — every Harness drive plan made here, and how it went. */
+    plans: string;
 }
 export declare function reticleDirPaths(root: string): ReticleDirPaths;
+/**
+ * A Harness drive's own record beside its run —.reticle/runs/<runId>.drive.json. Not a run: every
+ * reader that counts or syncs run files skips it.
+ */
+export declare const DRIVE_RECORD_SUFFIX = ".drive.json";
+/** Where evidence goes when no project could be named: `~/.reticle/unmatched/<id>`. */
+export declare const UNMATCHED_SUBDIR = "unmatched";
+/** Whether a root is one of those buckets: evidence from a page that never said its project. */
+export declare function isUnmatchedRoot(root: string): boolean;
 /** The verification-run artifact path for `runId`.reticle/runs/<runId>.json). */
 export declare function runPath(root: string, runId: RunId): string;
 /** The journal directory for `sessionId` (.reticle/sessions/<id>). Guard the id first. */
@@ -86,6 +97,11 @@ export declare function visualPath(root: string, name: string, runtime?: string)
  * every pre-existing baseline came from a driven browser, and moving them would orphan them.
  */
 export declare function visualDir(root: string, runtime?: string): string;
+/**
+ * Where one run's step screenshots live: `.reticle/visual/runs/<runId>/`. Throws on an unsafe run id,
+ * like every other path built from one.
+ */
+export declare function stepShotDir(root: string, runId: string): string;
 /** The overlay-diff PNG path for `name`.reticle/visual/<name>.diff.png). */
 export declare function visualDiffPath(root: string, name: string, runtime?: string): string;
 /**

package/dist/memory/project/dir/reticle-dir.js

@@ -1,6 +1,6 @@
-import { dirname, join } from 'node:path';
+import { basename, dirname, join } from 'node:path';
 import { realmOf } from '@reticlehq/core';
-import { CONTRACT_FILE_VERSION, ContractFileSchema, ContractReadError, FLOW_NAME_PATTERN, SAFE_SEGMENT_PATTERN, ReticleDir, } from '@reticlehq/core';
+import { CONTRACT_FILE_VERSION, ContractFileSchema, ContractReadError, FLOW_NAME_PATTERN, SAFE_SEGMENT_PATTERN, ReticleDir, STEP_SCREENSHOT, } from '@reticlehq/core';
 export function reticleDirPaths(root) {
     return {
         root,
@@ -10,7 +10,6 @@ export function reticleDirPaths(root) {
         project: join(root, ReticleDir.PROJECT_FILE),
         impact: join(root, ReticleDir.IMPACT_FILE),
         intent: join(root, ReticleDir.INTENT_FILE),
-        fillValues: join(root, ReticleDir.FILL_VALUES_FILE),
         visual: join(root, ReticleDir.VISUAL_SUBDIR),
         runs: join(root, ReticleDir.RUNS_SUBDIR),
         sessions: join(root, ReticleDir.SESSIONS_SUBDIR),
@@ -20,8 +19,23 @@ export function reticleDirPaths(root) {
         flake: join(root, ReticleDir.FLAKE_FILE),
         coverage: join(root, ReticleDir.COVERAGE_FILE),
         tiers: join(root, ReticleDir.TIERS_FILE),
+        // Beside `intent/`, not in it: `intent/` is committed, and this is the user's own words.
+        request: join(root, ReticleDir.REQUEST_FILE),
+        plans: join(root, ReticleDir.PLANS_SUBDIR),
     };
 }
+/**
+ * A Harness drive's own record beside its run —.reticle/runs/<runId>.drive.json. Not a run: every
+ * reader that counts or syncs run files skips it.
+ */
+export const DRIVE_RECORD_SUFFIX = '.drive.json';
+/** Where evidence goes when no project could be named: `~/.reticle/unmatched/<id>`. */
+export const UNMATCHED_SUBDIR = 'unmatched';
+/** Whether a root is one of those buckets: evidence from a page that never said its project. */
+export function isUnmatchedRoot(root) {
+    const parent = dirname(root);
+    return UNMATCHED_SUBDIR === basename(parent) && ReticleDir.ROOT === basename(dirname(parent));
+}
 /** The verification-run artifact path for `runId`.reticle/runs/<runId>.json). */
 export function runPath(root, runId) {
     return join(root, ReticleDir.RUNS_SUBDIR, `${runId}.json`);
@@ -90,6 +104,15 @@ export function visualDir(root, runtime) {
         ? join(visual, runtime)
         : visual;
 }
+/**
+ * Where one run's step screenshots live: `.reticle/visual/runs/<runId>/`. Throws on an unsafe run id,
+ * like every other path built from one.
+ */
+export function stepShotDir(root, runId) {
+    if (!isValidRunId(runId))
+        throw new Error(`invalid run id: ${JSON.stringify(runId)}`);
+    return join(root, ReticleDir.VISUAL_SUBDIR, STEP_SCREENSHOT.RUNS_DIR, runId);
+}
 /** The overlay-diff PNG path for `name`.reticle/visual/<name>.diff.png). */
 export function visualDiffPath(root, name, runtime) {
     return join(visualDir(root, runtime), `${name}.diff.png`);

package/dist/memory/project/link-directory.d.ts

@@ -0,0 +1,15 @@
+import { type ConfigDiscovery } from '../../command/cli/config/config-discovery.js';
+/**
+ * The declared project that encloses `cwd`, else the one project declared below it, else `cwd`
+ * itself. Several candidates below and none enclosing is a choice the caller must make, so `cwd` is
+ * kept rather than one picked silently.
+ */
+export declare function linkDirectoryFor(cwd: string, discovery: ConfigDiscovery): string;
+/**
+ * The `.reticle` a command run here owns: the project's, when this folder is in or above exactly one
+ * declared project or already holds a `.reticle`. Undefined anywhere else, so a lease opened from a
+ * home directory never plants a `.reticle` in it.
+ */
+export declare function callerArtifactRoot(cwd: string): string | undefined;
+/** `linkDirectoryFor` over this machine's own discovery from `cwd`. */
+export declare function linkDirectoryFrom(cwd: string): string;

package/dist/memory/project/link-directory.js

@@ -0,0 +1,44 @@
+/**
+ * The directory `reticle link` binds: the project a session from here would write its runs into.
+ *
+ * Runs land in the root the artifact resolver picks for the page's project, which comes from the same
+ * config discovery used here. Binding `cwd` instead left a monorepo's `apps/web/.reticle` unlinked
+ * while every run of that app landed in it.
+ */
+import { existsSync } from 'node:fs';
+import { join, resolve, sep } from 'node:path';
+import { ReticleDir } from '@reticlehq/core';
+import { discoverProjectConfigs, hasProjectConfig, } from '../../command/cli/config/config-discovery.js';
+/** `inner` is `outer` or sits inside it. */
+const within = (inner, outer) => inner === outer || inner.startsWith(outer.endsWith(sep) ? outer : `${outer}${sep}`);
+/**
+ * The declared project that encloses `cwd`, else the one project declared below it, else `cwd`
+ * itself. Several candidates below and none enclosing is a choice the caller must make, so `cwd` is
+ * kept rather than one picked silently.
+ */
+export function linkDirectoryFor(cwd, discovery) {
+    const here = resolve(cwd);
+    const enclosing = discovery.found
+        .map((found) => found.directory)
+        .filter((directory) => within(here, directory))
+        .sort((a, b) => b.length - a.length)[0];
+    if (enclosing !== undefined)
+        return enclosing;
+    const below = discovery.found.filter((found) => within(found.directory, here));
+    const only = 1 === below.length ? below[0] : undefined;
+    return only === undefined ? here : only.directory;
+}
+/**
+ * The `.reticle` a command run here owns: the project's, when this folder is in or above exactly one
+ * declared project or already holds a `.reticle`. Undefined anywhere else, so a lease opened from a
+ * home directory never plants a `.reticle` in it.
+ */
+export function callerArtifactRoot(cwd) {
+    const dir = linkDirectoryFrom(cwd);
+    const root = join(dir, ReticleDir.ROOT);
+    return hasProjectConfig(dir) || existsSync(root) ? root : undefined;
+}
+/** `linkDirectoryFor` over this machine's own discovery from `cwd`. */
+export function linkDirectoryFrom(cwd) {
+    return linkDirectoryFor(cwd, discoverProjectConfigs(cwd));
+}

package/dist/memory/project/project-tools.js

@@ -1,4 +1,5 @@
 import { z } from 'zod';
+import { describeSync, overallStatus, readSyncSummary } from './sync-status.js';
 import { sessionRoot } from './session-root.js';
 import { projectForRoot } from './project-for-root.js';
 import { ProjectReadError, RunStatus } from '@reticlehq/core';
@@ -94,6 +95,7 @@ export const PROJECT_TOOLS = [
         description: 'Read cross-run history from .reticle/project.json — the memory of how past runs behaved. With { name } it also returns the last run for that flow plus a diff-vs-last summary (status change, regressed flag, consoleErrors/driftSteps deltas) so you can answer "did it behave like last time?". `diff` is the lightweight status/console/drift delta vs the previous run of that NAME; `runDiff` is the per-flow duration/status delta between the two most-recent full verification artifacts ("step 3: 412ms -> 987ms (+140%), +2 requests"). When logged in to Reticle, also returns `cloud`: the team\'s server-side regression report (broken/changed flows vs before) — the durable memory a fresh or context-lost agent can rely on even when local history is empty. Returns { runs, learned?, lastRun?, diff?, runDiff?, cloud? } or { error, reason, cloud? }.',
         inputSchema: {
             name: z.string().optional().describe('Filter runs by this name. Omit to return all runs.'),
+            push: z.boolean().optional().describe('Sync with the platform now, before answering.'),
             limit: countSchema
                 .optional()
                 .describe('Most-recent N runs to return. Defaults to 25 — the full history is unbounded and grows with every run (measured at ~20KB / ~5,000 tokens on a modest project), which is a large slice of an agent context for data it mostly does not read. `totalRuns` always reports the true count, so a cap is never silent.'),
@@ -110,14 +112,31 @@ export const PROJECT_TOOLS = [
             cloud: z.unknown().optional(),
         },
         handler: async (deps, args) => {
-            const cloud = await cloudRegression(deps, asString(args['sessionId']));
-            const withCloud = (obj) => cloud === undefined ? obj : { ...obj, cloud };
+            // A push asked for is done first, so the status below describes what it achieved.
+            if (true === args['push'])
+                await deps.syncNow?.().catch(() => undefined);
+            const root = sessionRoot(deps, asString(args['sessionId']));
+            const linked = (await deps.linkedCloud?.().catch(() => null)) ?? null;
+            const summary = readSyncSummary(root, null !== linked);
+            const sync = {
+                ...summary,
+                status: overallStatus(summary),
+                said: describeSync(summary, deps.now()),
+            };
+            const regression = await cloudRegression(deps, asString(args['sessionId']));
+            // Where this project's work stands with the platform rides in `cloud` beside the team's
+            // regression report: the two answers to "what does the platform know about this project".
+            const cloud = {
+                ...('object' === typeof regression && null !== regression ? regression : {}),
+                sync,
+            };
+            const withCloud = (obj) => ({ ...obj, cloud });
             const project = projectForRoot(deps, sessionRoot(deps, asString(args['sessionId'])));
             const read = await project.read();
             if (!read.ok) {
                 return withCloud({
                     error: read.reason === ProjectReadError.MISSING
-                        ? 'no .reticle/project.json yet — run a flow (reticle_flow_replay) or reticle_run_record first'
+                        ? 'no .reticle/project.json yet — the first verified run writes it: drive one step with reticle_act_and_wait and an `until`'
                         : '.reticle/project.json is malformed — it will self-heal on the next recorded run',
                     reason: read.reason,
                 });

package/dist/memory/project/root-claims.d.ts

@@ -0,0 +1,6 @@
+/** Claim `root` for the session a lease registers. Refuses anything but an absolute `.reticle`. */
+export declare function claimArtifactRoot(leaseId: string, root: string): void;
+/** The root claimed for this session, by its id or by the lease marker on its url. */
+export declare function claimedArtifactRoot(sessionId: string, url: string | undefined): string | undefined;
+/** Forget a lease's claim, once the lease is released. */
+export declare function dropArtifactRootClaim(leaseId: string): void;

package/dist/memory/project/root-claims.js

@@ -0,0 +1,39 @@
+/**
+ * Which `.reticle` a leased session writes into, when whoever opened the lease said so.
+ *
+ * The resolver can only go on the page's project id and origin, and a page with no project id lands
+ * in `~/.reticle/unmatched/`, which nothing links or syncs. A lease opened by `reticle try`, a chat
+ * drive or `verify` from a linked folder knows better: the run belongs to the folder that asked.
+ *
+ * Keyed by the lease id, which the leased tab carries as `__reticle_session` on its url, so a
+ * reconnect after a navigation, or an app that names its own session, still finds the claim. Lives
+ * until the lease is released.
+ */
+import { basename, isAbsolute } from 'node:path';
+import { RETICLE_URL_PARAM, ReticleDir } from '@reticlehq/core';
+const claims = new Map();
+/** Claim `root` for the session a lease registers. Refuses anything but an absolute `.reticle`. */
+export function claimArtifactRoot(leaseId, root) {
+    if (!isAbsolute(root) || ReticleDir.ROOT !== basename(root))
+        throw new Error(`root must be an absolute path to a ${ReticleDir.ROOT} folder, got ${root}`);
+    claims.set(leaseId, root);
+}
+/** The root claimed for this session, by its id or by the lease marker on its url. */
+export function claimedArtifactRoot(sessionId, url) {
+    const direct = claims.get(sessionId);
+    if (direct !== undefined)
+        return direct;
+    if (url === undefined)
+        return undefined;
+    try {
+        const lease = new URL(url).searchParams.get(RETICLE_URL_PARAM.SESSION);
+        return null === lease ? undefined : claims.get(lease);
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Forget a lease's claim, once the lease is released. */
+export function dropArtifactRootClaim(leaseId) {
+    claims.delete(leaseId);
+}

package/dist/memory/project/session-root.d.ts

@@ -1,5 +1,23 @@
 import type { ProjectId } from '@reticlehq/core';
 import type { ToolDeps } from '../../surface/tools/tool-kit.js';
+/**
+ * Which project a call is about, and the page origin it came through.
+ *
+ * The projectId alone is not an address: every git worktree carries the same committed
+ * `.reticle.json`, so a daemon serving several worktrees sees one id for all of them. The origin
+ * names the dev server that served the page, and the resolver uses it to pick the checkout that
+ * server runs in. Carried as one value so no caller can resolve with half of it -- a flow saved
+ * through the worktree and replayed through the id alone would land in one tree and be read from
+ * another.
+ */
+export interface ProjectTarget {
+    projectId: ProjectId | undefined;
+    origin?: string | undefined;
+    /** The root whoever leased this session claimed for it (see `root-claims.ts`), which wins. */
+    claimedRoot?: string | undefined;
+}
+/** The target for a caller that genuinely holds no session -- the id is all there is. */
+export declare function projectOnly(projectId: ProjectId | undefined): ProjectTarget;
 /**
  * The `.reticle` directory a tool call's artifacts belong in.
  *
@@ -24,7 +42,7 @@ export declare function sessionRoot(deps: ToolDeps, sessionId: string | undefine
  * place and the id from another. `sessionRoot` is now this function plus a lookup, so the two
  * cannot disagree about what a resolved root is.
  */
-export declare function rootForProjectId(deps: ToolDeps, projectId: ProjectId | undefined): string;
+export declare function rootForTarget(deps: ToolDeps, target: ProjectTarget): string;
 /**
  * The PROJECT directory -- one level above `.reticle` -- for a caller that runs a tool in a tree
  * rather than writing a file into one. `git diff` is the case: it was being run in the daemon's
@@ -50,3 +68,10 @@ export declare function projectDirFor(deps: ToolDeps, sessionId: string | undefi
  * there is no answer either.
  */
 export declare function sessionProjectId(deps: ToolDeps, sessionId: string | undefined): ProjectId | undefined;
+/**
+ * `sessionTarget` for the paths that degrade instead of refusing: replay and learning resolve a
+ * missing session to the global store, and keep doing so -- with the origin when there is one.
+ */
+export declare function safeSessionTarget(deps: ToolDeps, sessionId: string | undefined): ProjectTarget;
+/** `sessionProjectId` plus the origin the session's page was served from. Same refusals. */
+export declare function sessionTarget(deps: ToolDeps, sessionId: string | undefined): ProjectTarget;

package/dist/memory/project/session-root.js

@@ -1,4 +1,24 @@
 import { dirname } from 'node:path';
+import { claimedArtifactRoot } from './root-claims.js';
+/**
+ * The scheme://host:port a session's page was served from. Local rather than the session manager's
+ * copy because `memory/project` does not reach `portal/session`, and five lines are cheaper than a
+ * new dependency between the two.
+ */
+function originOf(url) {
+    if (url === undefined)
+        return undefined;
+    try {
+        return new URL(url).origin;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The target for a caller that genuinely holds no session -- the id is all there is. */
+export function projectOnly(projectId) {
+    return { projectId };
+}
 /**
  * The `.reticle` directory a tool call's artifacts belong in.
  *
@@ -26,7 +46,7 @@ export function sessionRoot(deps, sessionId) {
     // nothing its answer could change, so that one case skips the lookup and costs what it always
     // did. Every embedder of this engine, and every older construction of ToolDeps, is on it.
     const nothingToRefuse = deps.artifactRootFor === undefined && sessionId === undefined;
-    return rootForProjectId(deps, nothingToRefuse ? undefined : sessionProjectId(deps, sessionId));
+    return rootForTarget(deps, nothingToRefuse ? projectOnly(undefined) : sessionTarget(deps, sessionId));
 }
 /**
  * The same answer for a caller that already holds the projectId rather than a sessionId.
@@ -37,8 +57,10 @@ export function sessionRoot(deps, sessionId) {
  * place and the id from another. `sessionRoot` is now this function plus a lookup, so the two
  * cannot disagree about what a resolved root is.
  */
-export function rootForProjectId(deps, projectId) {
-    return deps.artifactRootFor?.(projectId).root ?? deps.reticleRoot;
+export function rootForTarget(deps, target) {
+    if (target.claimedRoot !== undefined)
+        return target.claimedRoot;
+    return deps.artifactRootFor?.(target.projectId, target.origin).root ?? deps.reticleRoot;
 }
 /**
  * The PROJECT directory -- one level above `.reticle` -- for a caller that runs a tool in a tree
@@ -74,12 +96,34 @@ export function projectDirFor(deps, sessionId) {
  * from this file so they cannot disagree again.
  */
 export function sessionProjectId(deps, sessionId) {
+    return sessionTarget(deps, sessionId).projectId;
+}
+/**
+ * `sessionTarget` for the paths that degrade instead of refusing: replay and learning resolve a
+ * missing session to the global store, and keep doing so -- with the origin when there is one.
+ */
+export function safeSessionTarget(deps, sessionId) {
+    try {
+        return sessionTarget(deps, sessionId);
+    }
+    catch {
+        return projectOnly(undefined);
+    }
+}
+/** `sessionProjectId` plus the origin the session's page was served from. Same refusals. */
+export function sessionTarget(deps, sessionId) {
     try {
-        return deps.sessions.resolve(sessionId).projectId;
+        const session = deps.sessions.resolve(sessionId);
+        const claimedRoot = claimedArtifactRoot(session.id, session.url);
+        return {
+            projectId: session.projectId,
+            origin: originOf(session.url),
+            ...(claimedRoot === undefined ? {} : { claimedRoot }),
+        };
     }
     catch (cause) {
         if (sessionId === undefined)
-            return undefined;
+            return projectOnly(undefined);
         throw unresolvedTargetRefusal(sessionId, cause);
     }
 }

package/dist/memory/project/sync-status.d.ts

@@ -0,0 +1,85 @@
+import type { CloudSyncState } from '../cloud/sync-cycle.js';
+import { type UnsyncedRoot } from '../cloud/unsynced-roots.js';
+import type { FileSystemPort } from './fs/fs-port.js';
+export declare const SyncStatus: {
+    readonly ON_PLATFORM: "on-platform";
+    readonly PENDING: "pending";
+    readonly REFUSED: "refused";
+    readonly LOCAL_ONLY: "local-only";
+};
+export type SyncStatus = (typeof SyncStatus)[keyof typeof SyncStatus];
+export interface SyncSummary {
+    linked: boolean;
+    /** Runs on this machine. */
+    runs: number;
+    onPlatform: number;
+    pending: number;
+    /** The runs the platform refused in their current form, with its reason. */
+    refused: {
+        runId: string;
+        reason: string;
+    }[];
+    /** Refusals beyond the ones named. */
+    refusedMore: number;
+    lastPushAt?: number;
+    /** Why the last cycle failed, when it did. */
+    lastError?: string;
+    /** The newest run the platform holds in its current form: what "see it in your dashboard" opens. */
+    latestOnPlatform?: string;
+}
+export declare function summarizeSync(input: {
+    linked: boolean;
+    runs: readonly {
+        runId: string;
+        payload: unknown;
+    }[];
+    state: CloudSyncState;
+}): SyncSummary;
+/**
+ * Where this project's dashboard lives, if `reticle link` recorded one.
+ *
+ * Read from the link file rather than derived from the API url, because the API origin and the
+ * console origin are different hosts in every deployment that is not a laptop. Synchronous and
+ * best-effort, like every other read in this file: a missing or malformed link file means no link
+ * in the HUD, never a failed tool call.
+ */
+export declare function readDashboardUrl(reticleRoot: string): string | undefined;
+/** The platform project this folder is linked to, from the same link file. */
+export declare function readLinkedProjectId(reticleRoot: string): string | undefined;
+/** The refused credential, in words: what a person has to act on. */
+export declare const KEY_REFUSED = "the platform refused this project's API key: it was revoked, or its owner no longer has access to the workspace";
+/**
+ * Why a credential was refused: the platform's own sentence when it names the reason ("You were
+ * removed from Acme.", a key whose owner lost the project), else ours. Reads an answer body.
+ */
+export declare function refusalSaid(body: string): string;
+/** Why the platform refused this project's key at the last sync, or undefined. Never throws. */
+export declare function keyRefusalAtLastSync(reticleRoot: string): string | undefined;
+/** Whether the platform refused this project's key at the last sync. Never throws. */
+export declare function keyRefusedAtLastSync(reticleRoot: string): boolean;
+/** The dashboard's page for one run: the console's `/runs/:runId` route, at the dashboard's origin. */
+export declare const DASHBOARD_RUN_PATH = "/runs/";
+export declare const DASHBOARD_PLAN_PATH = "/plans/";
+export declare function dashboardRunUrl(dashboardUrl: string, runId: string): string;
+/** The line a command prints once its run reached the platform. */
+export declare function seeRunLine(dashboardUrl: string, runId: string): string;
+/**
+ * A saved Harness plan's page on the dashboard, beside its runs, under its project: opened under
+ * another project's sticky scope the page answered "We could not find that plan" to its owner.
+ */
+export declare function dashboardPlanUrl({ dashboardUrl, planId, projectId, }: {
+    dashboardUrl: string;
+    planId: string;
+    projectId?: string | undefined;
+}): string;
+/** This project's summary, read from its `.reticle`. Never throws: an unreadable record is empty. */
+export declare function readSyncSummary(reticleRoot: string, linked: boolean): SyncSummary;
+/** One status for the whole project: the worst thing true of it. */
+export declare function overallStatus(summary: SyncSummary): SyncStatus;
+/** The summary in one sentence an agent can repeat to a person. */
+export declare function describeSync(summary: SyncSummary, now: number): string;
+/**
+ * Every project folder this machine knows with runs or flows the platform never got, linked by its OWN link
+ * file or not. `reticle sync` and `doctor` print these; a daemon tracks the same through its cycle.
+ */
+export declare function machineUnsyncedRoots(fs: FileSystemPort, home: string, env: NodeJS.ProcessEnv): Promise<UnsyncedRoot[]>;