@neta-art/cohub-cli 7.0.1 → 7.1.1

package/dist/runtime/space-binding.js

@@ -0,0 +1,305 @@
+import { createHash, randomUUID } from "node:crypto";
+import { chmod, mkdir, open, readFile, readdir, realpath, rename, rm, rmdir, stat, utimes, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+const CONFIG_DIR_NAME = ".config";
+const CONFIG_FILE_NAME = "runtime-spaces.json";
+const LOCK_STALE_MS = 5 * 60 * 1000;
+const LOCK_HEARTBEAT_MS = 60 * 1000;
+const LOCK_RETRY_MS = 100;
+const LOCK_ATTEMPTS = 600;
+const GLOBAL_LOCK_SUFFIX = ".lock";
+export class RuntimeSpaceBindingsError extends Error {
+    name = "RuntimeSpaceBindingsError";
+}
+const missing = (error) => error?.code === "ENOENT";
+const nonEmptyString = (value) => typeof value === "string" && value.trim().length > 0;
+export function runtimeSpaceBindingsPath() {
+    return join(homedir(), CONFIG_DIR_NAME, "cohub", CONFIG_FILE_NAME);
+}
+export function normalizeRuntimeRoot(root) {
+    return resolve(root);
+}
+export async function canonicalRuntimeRoot(root) {
+    return realpath(normalizeRuntimeRoot(root));
+}
+function invalidBindings(path, detail) {
+    return new RuntimeSpaceBindingsError(`Runtime Space bindings are invalid${detail ? ` (${detail})` : ""}: ${path}`);
+}
+export function parseRuntimeSpaceBindings(raw, path = CONFIG_FILE_NAME) {
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        throw invalidBindings(path, "invalid JSON");
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw invalidBindings(path);
+    }
+    const record = value;
+    if (record.version !== 1 || !Array.isArray(record.bindings)) {
+        throw invalidBindings(path, "unsupported format");
+    }
+    const seen = new Set();
+    const bindings = [];
+    for (const item of record.bindings) {
+        if (!item || typeof item !== "object" || Array.isArray(item)) {
+            throw invalidBindings(path, "invalid binding");
+        }
+        const binding = item;
+        if (!nonEmptyString(binding.root) || !isAbsolute(binding.root)) {
+            throw invalidBindings(path, "binding root must be absolute");
+        }
+        if (!nonEmptyString(binding.key) || !nonEmptyString(binding.spaceId)) {
+            throw invalidBindings(path, "binding identity is incomplete");
+        }
+        const root = normalizeRuntimeRoot(binding.root);
+        const key = binding.key.trim();
+        const spaceId = binding.spaceId.trim();
+        const identity = `${key}\u0000${root}`;
+        if (seen.has(identity))
+            throw invalidBindings(path, "duplicate binding");
+        seen.add(identity);
+        bindings.push({ root, key, spaceId });
+    }
+    return { version: 1, bindings };
+}
+export async function readRuntimeSpaceBindings(path = runtimeSpaceBindingsPath()) {
+    try {
+        return parseRuntimeSpaceBindings(await readFile(path, "utf8"), path);
+    }
+    catch (error) {
+        if (missing(error))
+            return { version: 1, bindings: [] };
+        throw error;
+    }
+}
+export function findRuntimeSpaceBinding(bindings, input) {
+    const entries = Array.isArray(bindings) ? bindings : bindings.bindings;
+    const root = normalizeRuntimeRoot(input.root);
+    const key = input.key.trim();
+    return entries.find((binding) => binding.root === root && binding.key === key) ?? null;
+}
+function upsertRuntimeSpaceBinding(file, binding) {
+    const root = normalizeRuntimeRoot(binding.root);
+    const key = binding.key.trim();
+    const spaceId = binding.spaceId.trim();
+    const nextBinding = { root, key, spaceId };
+    const index = file.bindings.findIndex((item) => item.root === root && item.key === key);
+    if (index < 0) {
+        return { file: { version: 1, bindings: [...file.bindings, nextBinding] }, changed: true };
+    }
+    const current = file.bindings[index];
+    if (current?.root === root && current.key === key && current.spaceId === spaceId) {
+        return { file, changed: false };
+    }
+    const bindings = [...file.bindings];
+    bindings[index] = nextBinding;
+    return { file: { version: 1, bindings }, changed: true };
+}
+async function writeRuntimeSpaceBindings(path, file) {
+    await mkdir(dirname(path), { recursive: true, mode: 0o700 });
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    try {
+        const output = await open(temporary, "wx", 0o600);
+        try {
+            await output.writeFile(`${JSON.stringify(file, null, 2)}\n`, "utf8");
+            await output.sync();
+        }
+        finally {
+            await output.close();
+        }
+        await rename(temporary, path);
+        await chmod(path, 0o600);
+        if (process.platform !== "win32") {
+            const directory = await open(dirname(path), "r");
+            try {
+                await directory.sync();
+            }
+            finally {
+                await directory.close();
+            }
+        }
+    }
+    finally {
+        await rm(temporary, { force: true });
+    }
+}
+const statIfPresent = async (path) => stat(path, { bigint: false }).catch((error) => {
+    if (missing(error))
+        return null;
+    throw error;
+});
+async function lockSnapshot(lockPath) {
+    let names;
+    try {
+        names = await readdir(lockPath);
+    }
+    catch (error) {
+        // A malformed non-directory lock is not safe to reclaim automatically.
+        if (missing(error) || error.code === "ENOTDIR")
+            return null;
+        throw error;
+    }
+    if (names.length !== 1 || !names[0])
+        return null;
+    const owner = names[0];
+    const info = await statIfPresent(join(lockPath, owner));
+    return info ? { owner, mtimeMs: info.mtimeMs } : null;
+}
+async function reclaimStaleLock(lockPath, snapshot) {
+    const ownerPath = join(lockPath, snapshot.owner);
+    const current = await statIfPresent(ownerPath);
+    if (!current || Date.now() - current.mtimeMs <= LOCK_STALE_MS)
+        return false;
+    // Remove only the owner observed during the stale check. If another process
+    // replaced the lock, its owner token is different and rmdir stays harmless.
+    await rm(ownerPath, { force: true });
+    try {
+        await rmdir(lockPath);
+        return true;
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT" || code === "ENOTEMPTY" || code === "EEXIST")
+            return false;
+        throw error;
+    }
+}
+async function acquireLock(lockPath) {
+    await mkdir(dirname(lockPath), { recursive: true, mode: 0o700 });
+    for (let attempt = 0; attempt < LOCK_ATTEMPTS; attempt += 1) {
+        try {
+            await mkdir(lockPath, { mode: 0o700 });
+            const owner = randomUUID();
+            try {
+                // The owner token is the filename. Removing this exact file before
+                // rmdir makes an old process unable to remove a replacement lock.
+                await writeFile(join(lockPath, owner), "", { encoding: "utf8", mode: 0o600, flag: "wx" });
+            }
+            catch (error) {
+                await rm(join(lockPath, owner), { force: true });
+                await rmdir(lockPath).catch((cleanupError) => {
+                    const code = cleanupError.code;
+                    if (code !== "ENOENT" && code !== "ENOTEMPTY" && code !== "EEXIST")
+                        throw cleanupError;
+                });
+                throw error;
+            }
+            return owner;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            const snapshot = await lockSnapshot(lockPath);
+            if (snapshot && Date.now() - snapshot.mtimeMs > LOCK_STALE_MS) {
+                await reclaimStaleLock(lockPath, snapshot);
+                continue;
+            }
+            await delay(LOCK_RETRY_MS);
+        }
+    }
+    throw new RuntimeSpaceBindingsError("Timed out waiting for the Runtime Space bindings lock");
+}
+async function releaseLock(lockPath, owner) {
+    await rm(join(lockPath, owner), { force: true });
+    await rmdir(lockPath).catch((error) => {
+        const code = error.code;
+        if (code !== "ENOENT" && code !== "ENOTEMPTY" && code !== "EEXIST")
+            throw error;
+    });
+}
+async function refreshLock(lockPath, owner) {
+    const ownerPath = join(lockPath, owner);
+    const current = await stat(ownerPath).catch((error) => {
+        if (missing(error))
+            return null;
+        throw error;
+    });
+    if (!current)
+        return;
+    const now = new Date();
+    await utimes(ownerPath, now, now);
+}
+export async function withRuntimeSpaceBindingsLock(fn, options = {}) {
+    const path = options.path ?? runtimeSpaceBindingsPath();
+    const lockPath = options.lockPath ?? `${path}${GLOBAL_LOCK_SUFFIX}`;
+    const owner = await acquireLock(lockPath);
+    const heartbeat = setInterval(() => {
+        void refreshLock(lockPath, owner).catch(() => undefined);
+    }, LOCK_HEARTBEAT_MS);
+    heartbeat.unref?.();
+    try {
+        return await fn();
+    }
+    finally {
+        clearInterval(heartbeat);
+        await releaseLock(lockPath, owner);
+    }
+}
+function bindingLockPath(path, root, key) {
+    const digest = createHash("sha256").update(`${key}\u0000${root}`).digest("hex");
+    return `${path}.${digest}.lock`;
+}
+async function persistRuntimeSpaceBinding(path, binding) {
+    await withRuntimeSpaceBindingsLock(async () => {
+        const file = await readRuntimeSpaceBindings(path);
+        const result = upsertRuntimeSpaceBinding(file, binding);
+        if (result.changed)
+            await writeRuntimeSpaceBindings(path, result.file);
+    }, { path, lockPath: `${path}${GLOBAL_LOCK_SUFFIX}` });
+}
+export async function getRuntimeSpaceBinding(root, key, path = runtimeSpaceBindingsPath()) {
+    if (!nonEmptyString(key))
+        return null;
+    const canonicalRoot = await canonicalRuntimeRoot(root);
+    const file = await readRuntimeSpaceBindings(path);
+    return findRuntimeSpaceBinding(file, { root: canonicalRoot, key: key.trim() });
+}
+/**
+ * Resolve a local Runtime Space without silently creating duplicates.
+ * The per-binding lock covers creation; the shared file is locked only for
+ * short read-modify-write commits.
+ */
+export async function resolveRuntimeSpace(input) {
+    const root = await canonicalRuntimeRoot(input.root);
+    const explicitSpaceId = input.explicitSpaceId?.trim() || null;
+    const identityKey = input.identityKey?.trim() || null;
+    const path = input.path ?? runtimeSpaceBindingsPath();
+    // An explicit target remains usable even in an environment where there is no
+    // decodable identity to scope a persisted local binding to.
+    if (!identityKey) {
+        if (explicitSpaceId) {
+            await input.validateSpace?.(explicitSpaceId);
+            return { spaceId: explicitSpaceId, source: "explicit" };
+        }
+        throw new RuntimeSpaceBindingsError("Cannot remember a local Runtime Space without an authenticated identity");
+    }
+    const bindingKey = identityKey;
+    const lockPath = bindingLockPath(path, root, bindingKey);
+    return withRuntimeSpaceBindingsLock(async () => {
+        const file = await readRuntimeSpaceBindings(path);
+        if (explicitSpaceId) {
+            await input.validateSpace?.(explicitSpaceId);
+            await persistRuntimeSpaceBinding(path, { root, key: bindingKey, spaceId: explicitSpaceId });
+            return { spaceId: explicitSpaceId, source: "explicit" };
+        }
+        const existing = findRuntimeSpaceBinding(file, { root, key: bindingKey });
+        if (existing) {
+            await input.validateSpace?.(existing.spaceId);
+            return { spaceId: existing.spaceId, source: "binding" };
+        }
+        // Remote creation and the local binding commit are separate durability
+        // domains; a server-side idempotency key is needed to close this crash window.
+        const createdSpaceId = await input.createSpace();
+        if (!nonEmptyString(createdSpaceId)) {
+            throw new RuntimeSpaceBindingsError("Local Runtime Space creation returned no Space ID");
+        }
+        const spaceId = createdSpaceId.trim();
+        await input.validateSpace?.(spaceId);
+        await persistRuntimeSpaceBinding(path, { root, key: bindingKey, spaceId });
+        return { spaceId, source: "created" };
+    }, { path, lockPath });
+}

package/dist/runtime/turn-projection.d.ts

@@ -0,0 +1,43 @@
+import { type CanonicalProjectionTurn, type MessageToolCallsFile, type ProjectionInput, type ProjectionTarget, type SessionTurnRecord, type StoredIntermediateMessage, type TurnIntermediateMessagesFile } from "@neta-art/cohub";
+export type SessionTurnProjectionClient = {
+    session(sessionId: string): {
+        turns: {
+            listPaginated(options?: {
+                cursor?: number;
+                limit?: number;
+                direction?: "older" | "newer";
+            }, request?: {
+                signal?: AbortSignal;
+            }): Promise<{
+                turns: SessionTurnRecord[];
+                hasMore: boolean;
+                nextCursor: number | undefined;
+            }>;
+            get(turnId: string, request?: {
+                signal?: AbortSignal;
+            }): Promise<{
+                turn: SessionTurnRecord;
+            }>;
+            intermediate: {
+                get(turnId: string, messagesObjectKey?: string | null, options?: {
+                    signal?: AbortSignal;
+                }): Promise<TurnIntermediateMessagesFile | null>;
+                getToolCalls(turnId: string, message: StoredIntermediateMessage, options?: {
+                    signal?: AbortSignal;
+                }): Promise<MessageToolCallsFile | null>;
+            };
+        };
+    };
+};
+export type ProjectionSourceTurn = CanonicalProjectionTurn;
+export declare function hydrateSessionTurn(turn: SessionTurnRecord, client: ReturnType<SessionTurnProjectionClient["session"]>, signal?: AbortSignal): Promise<CanonicalProjectionTurn>;
+export declare function listSessionProjectionTurns(source: SessionTurnProjectionClient, sessionId: string, options?: {
+    afterSequence?: number | null;
+    throughSequence?: number | null;
+    excludeTurnId?: string | null;
+    signal?: AbortSignal;
+}): Promise<ProjectionSourceTurn[]>;
+export declare function getSessionProjectionTurn(source: SessionTurnProjectionClient, sessionId: string, turnId: string, signal?: AbortSignal): Promise<CanonicalProjectionTurn>;
+export declare function projectTurnBatch(input: Omit<ProjectionInput, "turns"> & {
+    turns: ProjectionSourceTurn[];
+}, target: ProjectionTarget, includeHeader?: boolean): import("@neta-art/cohub").NativeProjection;

package/dist/runtime/turn-projection.js

@@ -0,0 +1,127 @@
+import { projectNativeSession } from "@neta-art/cohub";
+const record = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : {};
+const iso = (value) => value ?? new Date(0).toISOString();
+const sourceSessionId = (turn) => turn.sourceSessionId ?? turn.sessionId;
+const sourceTurnId = (turn) => turn.sourceTurnId ?? turn.id;
+const userMessageId = (turn) => {
+    const value = record(turn.meta).userMessageId;
+    return typeof value === "string" && value ? value : `${turn.id}:user`;
+};
+function hydrateToolDetails(content, calls) {
+    const byId = new Map(calls.map((call) => [call.id, call]));
+    return content.map((block) => {
+        if (block.type === "tool_use") {
+            const call = byId.get(block.id);
+            return call ? { ...block, input: call.input } : block;
+        }
+        if (block.type === "tool_result") {
+            const call = byId.get(block.tool_use_id);
+            return call?.result ? { ...block, content: call.result.content ?? block.content, is_error: call.result.isError } : block;
+        }
+        return block;
+    });
+}
+async function hydrateIntermediateMessage(turn, message, client, signal) {
+    signal?.throwIfAborted();
+    const toolCalls = await client.turns.intermediate.getToolCalls(turn.id, message, { signal });
+    return {
+        id: message.id,
+        turnId: turn.id,
+        role: message.role,
+        content: hydrateToolDetails(message.content, toolCalls?.toolCalls ?? []),
+        provider: message.provider,
+        model: message.model,
+        usage: message.usage,
+        stopReason: message.stopReason,
+        errorMessage: message.errorMessage,
+        meta: message.meta,
+        sourceSessionId: message.sessionId,
+        sequence: message.sequence ?? 0,
+        createdAt: iso(message.createdAt),
+    };
+}
+async function mapWithConcurrency(items, concurrency, mapper) {
+    const results = new Array(items.length);
+    let next = 0;
+    const worker = async () => {
+        for (;;) {
+            const index = next++;
+            if (index >= items.length)
+                return;
+            const item = items[index];
+            if (item === undefined)
+                return;
+            results[index] = await mapper(item);
+        }
+    };
+    await Promise.all(Array.from({ length: Math.min(concurrency, items.length) }, worker));
+    return results;
+}
+export async function hydrateSessionTurn(turn, client, signal) {
+    const sourceId = sourceSessionId(turn);
+    const messages = [];
+    if (turn.userContent.length) {
+        messages.push({
+            id: userMessageId(turn), turnId: turn.id, role: "user", content: turn.userContent,
+            meta: { userMessageId: userMessageId(turn), turnId: turn.id }, sourceSessionId: sourceId,
+            sequence: turn.sequence * 1_000_000, createdAt: iso(turn.createdAt),
+        });
+    }
+    const objectKey = turn.intermediateIndex?.messagesObjectKey;
+    if (!objectKey && (turn.intermediateSummary?.messageCount ?? 0) > 0)
+        throw new Error(`Intermediate message index is unavailable for Turn ${turn.id}`);
+    if (objectKey) {
+        const archive = await client.turns.intermediate.get(turn.id, objectKey, { signal });
+        if (!archive)
+            throw new Error(`Intermediate messages are unavailable for Turn ${turn.id}`);
+        const intermediate = await mapWithConcurrency(archive.messages, 8, (message) => hydrateIntermediateMessage(turn, message, client, signal));
+        messages.push(...intermediate.map((message) => ({ ...message, sequence: turn.sequence * 1_000_000 + 100_000 + message.sequence })));
+    }
+    const hasFinalGenerationResult = messages.some((message) => message.role === "assistant" && message.meta?.messageKind === "generation_result" && ["completed", "failed"].includes(String(message.meta.generationStatus)));
+    if (turn.assistantContent?.length && !hasFinalGenerationResult) {
+        messages.push({
+            id: `${turn.id}:assistant`, turnId: turn.id, role: turn.intent === "compact" ? "system" : "assistant", content: turn.assistantContent,
+            provider: turn.provider, model: turn.model, usage: turn.finalUsage, stopReason: turn.stopReason, errorMessage: turn.errorMessage,
+            meta: { ...(turn.meta ?? {}), turnId: turn.id, createdAt: turn.createdAt }, sourceSessionId: sourceId,
+            sequence: turn.sequence * 1_000_000 + 900_000, createdAt: iso(turn.createdAt),
+        });
+    }
+    messages.sort((left, right) => left.sequence - right.sequence || left.id.localeCompare(right.id));
+    return {
+        id: turn.id, sourceSessionId: sourceId, sourceTurnId: sourceTurnId(turn), sequence: turn.sequence,
+        status: turn.status, intent: turn.intent, provider: turn.provider, model: turn.model,
+        userContent: turn.userContent, assistantContent: turn.assistantContent, meta: turn.meta,
+        createdAt: iso(turn.createdAt), startedAt: turn.startedAt, completedAt: turn.completedAt, durationMs: turn.durationMs,
+        messages,
+    };
+}
+export async function listSessionProjectionTurns(source, sessionId, options = {}) {
+    const client = source.session(sessionId);
+    const turns = [];
+    const throughSequence = options.throughSequence ?? null;
+    let cursor = options.afterSequence && options.afterSequence > 0 ? options.afterSequence : undefined;
+    for (;;) {
+        options.signal?.throwIfAborted();
+        const page = await client.turns.listPaginated({ cursor, limit: 100, direction: "newer" }, { signal: options.signal });
+        const visible = page.turns.filter((turn) => (throughSequence == null || turn.sequence <= throughSequence) && turn.id !== options.excludeTurnId && !["queued", "running", "abort_requested"].includes(turn.status));
+        turns.push(...visible);
+        if (throughSequence != null && page.turns.some((turn) => turn.sequence >= throughSequence))
+            break;
+        if (!page.hasMore)
+            break;
+        if (page.nextCursor === undefined || page.nextCursor === cursor)
+            throw new Error("Session Turn pagination did not advance");
+        cursor = page.nextCursor;
+    }
+    return mapWithConcurrency(turns, 4, (turn) => hydrateSessionTurn(turn, client, options.signal));
+}
+export async function getSessionProjectionTurn(source, sessionId, turnId, signal) {
+    const client = source.session(sessionId);
+    return hydrateSessionTurn((await client.turns.get(turnId, { signal })).turn, client, signal);
+}
+export function projectTurnBatch(input, target, includeHeader = true) {
+    const projection = projectNativeSession(input, target);
+    if (includeHeader)
+        return projection;
+    return { ...projection, records: projection.records.filter((record) => record.sourceTurnId !== null) };
+}

package/dist/space.d.ts

@@ -10,6 +10,7 @@ export declare function identityKeyFrom(input: {
     idToken?: string | null;
     accessToken?: string | null;
 }): string | null;
+export declare function currentIdentityKey(): string | null;
 /** Exported for tests; production always uses `CACHE_PATH`. */
 export declare function readDefaultSpaceCache(path: string, key: string, now?: number): string | null;
 export declare function clearDefaultSpaceCache(): void;
@@ -25,8 +26,15 @@ export declare function resolveDefaultSpace(): Promise<string | null>;
 /** Shared exit for commands that need a space but resolved none. */
 export declare function missingSpaceError(): never;
 /**
- * Target space for a command: explicit `-s`/`COHUB_SPACE_ID` first, then the
- * user's home space. Exits with guidance when neither is available; request
- * failures go through the shared HTTP error handler.
+ * Resolve a Space from an optional explicit target, the current directory
+ * binding, and finally the user's Home Space.
  */
+export declare function resolveBoundSpace(options?: {
+    cwd?: string;
+    bindingsPath?: string;
+}): Promise<string | null>;
+export declare function resolveSpaceTarget(target?: string | null, options?: {
+    cwd?: string;
+    bindingsPath?: string;
+}): Promise<string>;
 export declare function resolveSpace(program: Command): Promise<string>;

package/dist/space.js

@@ -4,6 +4,7 @@ import { join } from "node:path";
 import { resolveCohubEnvironment } from "@neta-art/cohub";
 import { readAuthSession } from "./auth.js";
 import { createClient } from "./client.js";
+import { getRuntimeSpaceBinding } from "./runtime/space-binding.js";
 import { error, handleHttp } from "./output.js";
 const CONFIG_DIR = join(homedir(), ".config", "cohub");
 const CACHE_PATH = join(CONFIG_DIR, "default-space.json");
@@ -35,7 +36,7 @@ export function identityKeyFrom(input) {
     const sub = jwtClaim(input.idToken, "sub") ?? jwtClaim(input.accessToken, "sub");
     return sub ? `${input.env}:${sub}` : null;
 }
-function identityKey() {
+export function currentIdentityKey() {
     const session = readAuthSession();
     return identityKeyFrom({
         env: resolveCohubEnvironment(),
@@ -97,7 +98,7 @@ export function explicitSpace(program) {
  */
 export function resolveDefaultSpace() {
     defaultSpacePromise ??= (async () => {
-        const key = identityKey();
+        const key = currentIdentityKey();
         if (key) {
             const cached = readDefaultSpaceCache(CACHE_PATH, key);
             if (cached)
@@ -116,10 +117,21 @@ export function missingSpaceError() {
     return error("No target space", "Add -s, --space <id> or set COHUB_SPACE_ID. Run `cohub auth login` to use your home space.");
 }
 /**
- * Target space for a command: explicit `-s`/`COHUB_SPACE_ID` first, then the
- * user's home space. Exits with guidance when neither is available; request
- * failures go through the shared HTTP error handler.
+ * Resolve a Space from an optional explicit target, the current directory
+ * binding, and finally the user's Home Space.
  */
+export async function resolveBoundSpace(options = {}) {
+    const bound = await getRuntimeSpaceBinding(options.cwd ?? process.cwd(), currentIdentityKey(), options.bindingsPath).catch(handleHttp);
+    return bound?.spaceId ?? null;
+}
+export async function resolveSpaceTarget(target, options = {}) {
+    const explicit = target?.trim() || process.env.COHUB_SPACE_ID?.trim() || null;
+    if (explicit)
+        return explicit;
+    return (await resolveBoundSpace(options))
+        ?? (await resolveDefaultSpace().catch(handleHttp))
+        ?? missingSpaceError();
+}
 export async function resolveSpace(program) {
-    return explicitSpace(program) ?? (await resolveDefaultSpace().catch(handleHttp)) ?? missingSpaceError();
+    return resolveSpaceTarget(explicitSpace(program));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "7.0.1",
+  "version": "7.1.1",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "engines": {
@@ -22,7 +22,7 @@
     "commander": "^15.0.0",
     "pixi.js": "^8.20.1",
     "sharp": "^0.35.4",
-    "@neta-art/cohub": "8.19.0"
+    "@neta-art/cohub": "8.20.1"
   },
   "publishConfig": {
     "access": "public"
@@ -38,6 +38,7 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
+    "verify:sandboxd": "node --import tsx scripts/verify-sandboxd-release.ts",
     "test": "node ../../scripts/test/run.mjs 'tests/**/*.test.ts'",
     "test:runtime": "node --import tsx --test tests/runtime-*.integration.ts",
     "test:runtime:native": "node --import tsx tests/runtime-native.smoke.ts",