@shardflux/cli 0.14.1 → 0.14.2

package/CHANGELOG.md

@@ -1,11 +1,18 @@
 # Changelog
 
+## 0.14.2
+
+- `shard agents open` accepts conversation keys, VM keys and conversation ids, reattaching the existing Claude Code or Codex session in its conversation worktree. The menu bar's Open action uses the same path; legacy agents retain their existing behavior.
+- Start local projects without Git history: initialize a repository on `main` when needed and create one empty initial commit, preserving existing files and staged work. Use a command-local Shardflux identity when Git identity is missing, and report actionable `git_error` failures.
+
 ## 0.14.1
 
 - `shard ssh-proxy` connects faster: host trust (host key pin and device key) runs alongside the tunnel start, with no guest byte reaching OpenSSH before the host key is pinned, and a reconnect checks its device key with one read.
 
 ## 0.14.0
 
+- Mirror native conversation transcripts when the guest includes its empty append-lock file.
+
 - Ask for device approval before preparing the VM-backed local worktree; report a failed preparation as the request's result and bound preparation to 30 seconds.
 - Keep desktop programs running after a command returns with detached `setsid -f` guidance.
 - Allocate one VM per new ACP conversation, with cached initial model choices and live updates from that same VM.

package/README.md

@@ -1153,6 +1153,9 @@ Set `--reachable 30m` when opening a workspace to choose how long waiting agents
 ## Cloud agents (0.13.2+)
 
 Run `shard ./` in your project to start Claude Code or Codex, usable immediately while setup runs in the background.
+
+New project folders are ready to use: `shard ./` and `shard agents new` initialize Git on `main` when needed and create an empty initial commit (CLI 0.14.2+). Existing files and staged work stay yours; the initial commit contains no files. Repositories without commits keep their current branch. If Git identity is missing, that one commit uses `Shardflux <noreply@shardflux.dev>` without changing your Git configuration.
+
 Your **machine** carries credentials, tools, dotfiles, logins and agent config; the project's **template** carries
 toolchains, dependencies, services and project secrets. Both are private filesystem templates and include secrets
 as ordinary files. Browser logins and Claude/Codex config belong to the machine. Set up tools and secrets normally inside the VM;

package/dist/agent-commands.js

@@ -8,6 +8,7 @@ import { AgentStateStore } from "./agent-state.js";
 import { attachTerminal, cellConnector } from "./agent-terminal.js";
 import { prepareProjectTemplate } from "./project-template-setup.js";
 import { projectIdentity, projectLabels } from "./project-identity.js";
+import { ensureProjectGit } from "./project-git.js";
 import { json } from "./format.js";
 import { resolveWorkspace } from "./commands.js";
 import { savedMachine } from "./filesystem-state.js";
@@ -21,6 +22,8 @@ import { rememberLaunch } from "./agent-live.js";
 import { prepareAgentMachine } from "./agent-machine.js";
 import { installedTargets } from "./agent-targets.js";
 import { openDesktopWorkspace, queueT3Prewarm } from "./agent-target-commands.js";
+import { conversationWorkspace, conversationsUnavailable, getConversation, listConversations, resumeConversation } from "./conversations.js";
+import { conversationTerminal } from "./conversation-terminal.js";
 const active = (session) => session.state === 'running' || session.state === 'starting';
 /** `<slug>-<6 hex of sha256(identity)>`: the same repository gets the same key on every machine. */
 export function disambiguatedSlug(slug, identity) {
@@ -169,6 +172,10 @@ export const launchProject = async (ctx, values, [path = './', explicitApp]) =>
     if (agent !== 'main')
         agentName(agent);
     const labels = projectLabels(project, agent, app);
+    const local = like ? projectIdentity(path) : project;
+    // A cloud-only --like launch must not initialize an unrelated local checkout.
+    if (!like?.labels.repo_remote || like.labels.repo_remote === (local.remote ?? `file://${local.folder}`))
+        await ensureProjectGit(ctx, local.folder);
     const cloud = ctx.cloud();
     let existing = await cloud.workspaces.findByKey(`${project.slug}/${agent}`, { includeDeleted: false, signal: ctx.signal });
     const owner = agent === 'main' ? existing : like ?? await cloud.workspaces.findByKey(`${project.slug}/main`, { includeDeleted: false, signal: ctx.signal });
@@ -237,18 +244,52 @@ export const AGENT_HANDLERS = {
         }
         await syncCredentials(ctx);
         let ws;
-        if (agent.includes('/'))
-            ws = await ctx.cloud().workspace(agent, { create: false }).open();
+        let conversation;
+        if (/^conv_[a-z0-9]{26}$/.test(agent)) {
+            conversation = await resumeConversation(ctx, await getConversation(ctx, agent));
+            ws = await conversationWorkspace(ctx, conversation);
+        }
         else {
-            const project = projectIdentity('./');
-            if (!/^[a-z0-9][a-z0-9._-]{0,63}$/.test(agent))
-                throw new UsageError('agent must be a workspace key or an agent name');
-            ws = await ctx.cloud().workspace(`${project.slug}/${agent}`, { create: false }).open();
+            let key = agent;
+            if (!agent.includes('/')) {
+                const project = projectIdentity('./');
+                if (!/^[a-z0-9][a-z0-9._-]{0,63}$/.test(agent))
+                    throw new UsageError('agent must be a workspace key or an agent name');
+                key = `${project.slug}/${agent}`;
+            }
+            try {
+                ws = await ctx.cloud().workspace(key, { create: false }).open();
+            }
+            catch (error) {
+                if (!missing(error))
+                    throw error;
+                // A conversation key differs from its VM key (and survives VM moves).
+                let matches;
+                try {
+                    matches = (await listConversations(ctx)).filter(c => c.key === key);
+                }
+                catch (e) {
+                    if (conversationsUnavailable(e))
+                        throw error;
+                    throw e;
+                }
+                if (!matches.length)
+                    throw error;
+                if (matches.length !== 1)
+                    throw new UsageError('Use the conversation id.');
+                conversation = await resumeConversation(ctx, matches[0]);
+                ws = await conversationWorkspace(ctx, conversation);
+            }
+            // The menu bar supplies workspace_key from agents list, not the conversation key.
+            if (!conversation && ws.labels.shard_conversation) {
+                conversation = await resumeConversation(ctx, await getConversation(ctx, ws.labels.shard_conversation));
+                ws = await conversationWorkspace(ctx, conversation);
+            }
         }
         if (values.reachable !== undefined)
             ws = await ctx.cloud().workspaces.open({ key: ws.key, ...agentReachability(values), wait: false });
         const projectKey = typeof values.project === 'string' ? values.project : ws.labels.repo_remote || ws.labels.shard_project || ws.key;
-        const app = values.app ?? new AgentStateStore(ctx.store.dir).app(projectKey, ws.labels.app === 'codex' ? 'codex' : 'claude');
+        const app = conversation?.harness ?? values.app ?? new AgentStateStore(ctx.store.dir).app(projectKey, ws.labels.app === 'codex' ? 'codex' : 'claude');
         if (app === 'claude' && !await cloudClaudeLogin(ctx)) {
             progress(ctx, 'Signing in to cloud Claude (once per account)…');
             await loginClaudeInWorkspace(ctx, ws);
@@ -258,6 +299,8 @@ export const AGENT_HANDLERS = {
         if (ws.labels.shard_layer !== 'machine' && !(await savedMachine(ctx))?.template)
             await syncAgentConfig(ctx, ws);
         await prepareAgentMachine(ctx, ws);
+        if (conversation)
+            return conversationTerminal(ctx, ws, conversation, projectKey, values);
         return terminal(ctx, ws, app, (ws.labels.agent ?? agent).split('/').at(-1), projectKey, values);
     },
 };

package/dist/agent-git.d.ts

@@ -16,7 +16,7 @@ export interface GitRepository {
 }
 export type GitRepositories = Record<string, GitRepository>;
 export type GitRun = (args: string[]) => Promise<string>;
-export declare function gitRunner(root: string, env?: NodeJS.ProcessEnv, signal?: AbortSignal): GitRun;
+export declare function gitRunner(root: string, env?: NodeJS.ProcessEnv, signal?: AbortSignal, remoteHelper?: boolean): GitRun;
 export declare function agentName(name: string): string;
 export declare class AgentGit {
     readonly root: string;

package/dist/agent-git.js

@@ -2,18 +2,25 @@ import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
-import { UsageError } from "./errors.js";
+import { GitError, UsageError } from "./errors.js";
 import { AgentStateStore } from "./agent-state.js";
 import { gitPath } from "./git-remote-helper.js";
 const execute = promisify(execFile);
 const DAY = 86_400_000;
-export function gitRunner(root, env = process.env, signal) {
+export function gitRunner(root, env = process.env, signal, remoteHelper = true) {
     return async (args) => {
-        const result = await execute('git', ['--no-pager', '-C', root, ...args], {
-            env: { ...env, PATH: gitPath(env), GIT_TERMINAL_PROMPT: '0', GIT_MERGE_AUTOEDIT: 'no' },
-            timeout: 120_000, maxBuffer: 4 * 1024 * 1024, signal,
-        });
-        return result.stdout.trim();
+        try {
+            const result = await execute('git', ['--no-pager', '-C', root, ...args], {
+                env: { ...env, PATH: remoteHelper ? gitPath(env) : env.PATH, GIT_TERMINAL_PROMPT: '0', GIT_MERGE_AUTOEDIT: 'no' },
+                timeout: 120_000, maxBuffer: 4 * 1024 * 1024, signal,
+            });
+            return result.stdout.trim();
+        }
+        catch (error) {
+            if (signal?.aborted)
+                throw error;
+            throw new GitError(root, error);
+        }
     };
 }
 export function agentName(name) {

package/dist/agent-repository.js

@@ -2,7 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { mkdtemp, readFile, rm, stat } from 'node:fs/promises';
 import { homedir, tmpdir } from 'node:os';
 import { join, resolve } from 'node:path';
-import { CodedError } from "./errors.js";
+import { CodedError, UsageError } from "./errors.js";
 import { AgentStateStore } from "./agent-state.js";
 import { projectIdentity } from "./project-identity.js";
 import { localManifest, projectGit } from "./project-sync-manifest.js";
@@ -135,7 +135,7 @@ async function initializeProjectGit(cell, folder, root, signal, populate = false
         return;
     }
     if (top !== folder)
-        throw new Error('project sync requires the Git repository root; run shard there');
+        throw new UsageError('project sync requires the Git repository root; run shard there');
     const existing = await cell.exec.run(['git', '-C', root, 'rev-parse', '--verify', 'HEAD'], { timeoutMs: 5000, signal });
     if (existing.exitCode !== 0 && existing.exitCode !== 128)
         throw new Error('could not check workspace Git history');

package/dist/args.d.ts

@@ -1,4 +1,4 @@
-export declare const CLI_VERSION = "0.14.1";
+export declare const CLI_VERSION = "0.14.2";
 export interface OptionSpec {
     type: 'string' | 'boolean';
     short?: string;

package/dist/args.js

@@ -12,7 +12,7 @@
 import { parseArgs } from 'node:util';
 import { ACCOUNT_COMMANDS } from "./account-args.js";
 import { UsageError } from "./errors.js";
-export const CLI_VERSION = '0.14.1';
+export const CLI_VERSION = '0.14.2';
 export const GLOBAL_OPTIONS = {
     'api-url': { type: 'string', value: '<url>', description: 'API base URL (default $SHARDFLUX_API_URL, else https://api.shardflux.dev).' },
     json: { type: 'boolean', description: 'Print machine-readable JSON on stdout (errors as JSON on stderr).' },

package/dist/conversation-stash.js

@@ -62,6 +62,10 @@ export async function mirrorConversation(ctx, record, source) {
             throw new Error('Project transcript copy includes files outside the mirror bound.');
         let count = 0;
         for (const entry of manifest.entries) {
+            // Flush holds this empty regular file while appending the transcript.
+            // It is synchronization metadata, not native history to mirror.
+            if (entry.path === '.lock' && !entry.symlink && entry.size === 0 && entry.sha256 === 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855')
+                continue;
             if (entry.symlink || entry.path.includes('/') || !/^[a-zA-Z0-9_.-]+\.(jsonl|json)$/.test(entry.path))
                 throw new Error('Project transcript copy has an unsafe entry.');
             const file = join(dir, entry.path), expected = existsSync(file) ? createHash('sha256').update(readFileSync(file)).digest('hex') : '';

package/dist/conversation-terminal.d.ts

@@ -1,3 +1,8 @@
-import type { Handler } from './commands.js';
+import type { Workspace } from '@shardflux/sdk';
+import type { Ctx, Handler } from './commands.js';
+import type { Values } from './args.js';
+import type { Conversation } from './conversations.js';
+/** Every terminal entry point uses the durable conversation's native harness, worktree and session. */
+export declare function conversationTerminal(ctx: Ctx, ws: Workspace, c: Conversation, project: string, values: Values): Promise<number>;
 /** Select a durable conversation, then use the harness's native terminal for all interaction. */
 export declare const launchConversationProject: Handler;

package/dist/conversation-terminal.js

@@ -1,7 +1,7 @@
 import { randomUUID } from 'node:crypto';
 import { AgentStateStore } from "./agent-state.js";
 import { projectIdentity, projectLabels } from "./project-identity.js";
-import { createConversation, conversationWorkspace, conversationsUnavailable, listConversations, localConversations, rememberConversation, resumeConversation, restoreConversationBinding } from "./conversations.js";
+import { createConversation, conversationName, conversationWorkspace, conversationsUnavailable, listConversations, localConversations, rememberConversation, resumeConversation, restoreConversationBinding } from "./conversations.js";
 import { terminal } from "./agent-commands.js";
 import { cloudClaudeLogin, loginClaudeInWorkspace, requireClaudeTerminal } from "./claude-cloud-login.js";
 import { syncAgentCredentials } from "./agent-credentials.js";
@@ -13,6 +13,11 @@ import { ensureMenubar, MenubarManager } from "./menubar.js";
 import { UsageError } from "./errors.js";
 import { localResumeTerminal } from "./conversation-local-resume.js";
 import { agentReachability } from "./agent-reachability.js";
+/** Every terminal entry point uses the durable conversation's native harness, worktree and session. */
+export async function conversationTerminal(ctx, ws, c, project, values) {
+    await restoreConversationBinding(ctx, c, ws);
+    return terminal(ctx, ws, c.harness, conversationName(c), project, values, undefined, c.worktree_path, { id: c.id, session: c.harness_session_id });
+}
 /** Select a durable conversation, then use the harness's native terminal for all interaction. */
 export const launchConversationProject = async (ctx, values, [path = './', explicit]) => {
     const project = projectIdentity(path), store = new AgentStateStore(ctx.store.dir);
@@ -35,8 +40,7 @@ export const launchConversationProject = async (ctx, values, [path = './', expli
         const next = await resumeConversation(ctx, c);
         rememberConversation(ctx, next, project.folder);
         const ws = await conversationWorkspace(ctx, next);
-        await restoreConversationBinding(ctx, next, ws);
-        return terminal(ctx, ws, app, next.key.split('/').at(-1), project.remote ?? project.folder, values, undefined, next.worktree_path, { id: next.id, session: next.harness_session_id });
+        return conversationTerminal(ctx, ws, next, project.remote ?? project.folder, values);
     }
     await syncAgentCredentials(ctx.cloud(), { home: ctx.io.env.HOME, redact: value => ctx.addSecret(value) });
     const signedIn = app === 'claude' ? await cloudClaudeLogin(ctx) : true;
@@ -70,5 +74,5 @@ export const launchConversationProject = async (ctx, values, [path = './', expli
     if (!(await savedMachine(ctx))?.template)
         await syncAgentConfig(ctx, ws);
     await ensureMenubar(ctx.store.dir, ctx.apiUrl, new MenubarManager({ home: ctx.io.env.HOME, signal: ctx.signal }));
-    return terminal(ctx, ws, app, c.key.split('/').at(-1), project.remote ?? project.folder, values, undefined, c.worktree_path, { id: c.id, session: c.harness_session_id });
+    return conversationTerminal(ctx, ws, c, project.remote ?? project.folder, values);
 };

package/dist/conversations.js

@@ -3,6 +3,7 @@ import { ShardfluxApiError } from '@shardflux/sdk';
 import { AgentStateStore } from "./agent-state.js";
 import { gitRunner } from "./agent-git.js";
 import { projectIdentity } from "./project-identity.js";
+import { ensureProjectGit } from "./project-git.js";
 import { seedAgentRepository } from "./agent-repository.js";
 import { UsageError } from "./errors.js";
 import { conversationClient } from "./conversation-commands.js";
@@ -87,7 +88,8 @@ export async function restoreConversationBinding(ctx, c, ws) {
 }
 export async function createConversationRecord(ctx, folder, harness, route, name, allocated, idempotencyKey = randomUUID()) {
     const project = projectIdentity(folder);
-    // Detect the optional control-plane feature before applying the new Git contract to old APIs.
+    await ensureProjectGit(ctx, project.folder);
+    // Both the conversation API and its legacy workspace fallback need a usable local HEAD.
     await conversationClient(ctx).conversations.list({ limit: 1 });
     const git = gitRunner(project.folder, { ...process.env, ...ctx.io.env }, ctx.signal);
     const commit = await git(['rev-parse', 'HEAD']);

package/dist/errors.d.ts

@@ -28,6 +28,13 @@ declare class HintedError extends Error {
 export declare class UsageError extends HintedError {
     name: string;
 }
+/** Keep Git exit statuses for optional probes while reporting actionable CLI errors. */
+export declare class GitError extends HintedError {
+    name: string;
+    readonly code: string | number | undefined;
+    readonly stderr: string;
+    constructor(folder: string, cause: unknown);
+}
 /**
  * A refusal `shard` detects itself, with a stable code, its facts in `details` and the next step as `hint` (exit 1),
  * e.g. `repository_too_large` (0.13.3+) for Git history over the initial sync limit.

package/dist/errors.js

@@ -36,6 +36,22 @@ class HintedError extends Error {
 export class UsageError extends HintedError {
     name = 'UsageError';
 }
+/** Keep Git exit statuses for optional probes while reporting actionable CLI errors. */
+export class GitError extends HintedError {
+    name = 'GitError';
+    code;
+    stderr;
+    constructor(folder, cause) {
+        const failure = cause;
+        const detail = failure.stderr?.trim() || failure.message || 'Git command failed';
+        super(`Git failed in ${folder}: ${detail}\n${failure.code === 'ENOENT' ? 'Install Git and make sure git is on PATH, then run shard again.' : 'Resolve this Git error, then run shard again.'}`, failure.code === 'ENOENT'
+            ? 'Install Git and make sure git is on PATH, then run shard again.'
+            : `Check Git permissions, configuration and repository state with git -C ${JSON.stringify(folder)} status, resolve the error above, then run shard again.`);
+        this.code = failure.code;
+        this.stderr = failure.stderr ?? '';
+        this.cause = cause;
+    }
+}
 /**
  * A refusal `shard` detects itself, with a stable code, its facts in `details` and the next step as `hint` (exit 1),
  * e.g. `repository_too_large` (0.13.3+) for Git history over the initial sync limit.
@@ -199,6 +215,8 @@ export function describeError(err) {
         return { code: 'timeout', message: err.message, last_state: err.session.state, details: { session_id: err.session.session_id } };
     if (err instanceof UsageError)
         return { code: 'usage', message: err.message };
+    if (err instanceof GitError)
+        return { code: 'git_error', message: err.message, retryable: false };
     if (err instanceof CodedError)
         return { code: err.code, message: err.message, retryable: false, ...(err.details ? { details: err.details } : {}) };
     if (err instanceof CheckoutTimeoutError) {

package/dist/project-git.d.ts

@@ -0,0 +1,3 @@
+import type { Ctx } from './commands.js';
+/** Prepare only the selected project root. Never stage files or initialize a nested repository. */
+export declare function ensureProjectGit(ctx: Ctx, folder: string): Promise<void>;

package/dist/project-git.js

@@ -0,0 +1,52 @@
+import { existsSync, realpathSync } from 'node:fs';
+import { join } from 'node:path';
+import { gitRunner } from "./agent-git.js";
+import { GitError } from "./errors.js";
+/** Prepare only the selected project root. Never stage files or initialize a nested repository. */
+export async function ensureProjectGit(ctx, folder) {
+    const git = gitRunner(folder, { ...process.env, ...ctx.io.env, LC_ALL: 'C' }, ctx.signal, false);
+    let initialized = false;
+    try {
+        const top = await git(['rev-parse', '--show-toplevel']);
+        if (realpathSync(top) !== realpathSync(folder))
+            return;
+    }
+    catch (error) {
+        if (!(error instanceof GitError) || error.code !== 128 || !error.stderr.includes('not a git repository'))
+            throw error;
+        if (existsSync(join(folder, '.git')))
+            throw error;
+        await git(['init', '-b', 'main']);
+        initialized = true;
+    }
+    try {
+        await git(['rev-parse', '--verify', '--quiet', 'HEAD^{commit}']);
+        return;
+    }
+    catch (error) {
+        if (!(error instanceof GitError) || error.code !== 1)
+            throw error;
+        // An absent branch is unborn; a broken existing ref is a Git failure, not permission to replace it.
+        const branch = await git(['symbolic-ref', 'HEAD']);
+        const absent = await git(['show-ref', '--verify', '--quiet', branch]).then(() => false, (refError) => {
+            if (!(refError instanceof GitError) || refError.code !== 1)
+                throw refError;
+            return true;
+        });
+        if (!absent)
+            throw error;
+    }
+    // --only with no paths makes an empty commit even when the user already has staged files.
+    const commit = ['-c', 'core.hooksPath=/dev/null', 'commit', '--allow-empty', '--only', '-m', 'Initial commit'];
+    try {
+        await git(commit);
+    }
+    catch (error) {
+        if (!(error instanceof GitError) || !/Author identity unknown|Committer identity unknown|unable to auto-detect email address|empty ident name|no (?:name|email) was given/.test(error.stderr))
+            throw error;
+        await git(['-c', 'user.name=Shardflux', '-c', 'user.email=noreply@shardflux.dev', ...commit]);
+    }
+    ctx.io.stderr.write(initialized
+        ? `Initialized a git repository in ${folder} (shard tracks your project with git).\n`
+        : `Created an initial empty commit in ${folder}.\n`);
+}

package/dist/project-sync-manifest.js

@@ -3,6 +3,7 @@ import { execFile } from 'node:child_process';
 import { constants } from 'node:fs';
 import { lstat, open, readdir, readlink, realpath } from 'node:fs/promises';
 import { basename, dirname, join, relative, resolve, sep } from 'node:path';
+import { GitError } from "./errors.js";
 export const MAX_SYNC_FILE_BYTES = 64 * 1024 * 1024;
 export const MAX_SYNC_ENTRIES = 20_000;
 export function validSyncPath(path) {
@@ -46,13 +47,19 @@ export function parseManifest(manifest) {
 }
 export async function projectGit(folder, args, signal, input = '') {
     return new Promise((resolve, reject) => {
-        const child = execFile('git', ['-C', folder, '-c', 'core.fsmonitor=false', '-c', 'core.untrackedCache=false', '-c', 'core.hooksPath=/dev/null', ...args], { encoding: 'utf8', timeout: 30_000, maxBuffer: 4 << 20, signal, env: { ...process.env, GIT_TERMINAL_PROMPT: '0', GIT_OPTIONAL_LOCKS: '0' } }, (error, stdout) => {
-            if (error) {
-                const failure = Object.assign(new Error(error.message, { cause: error }), { code: error.code, stdout });
-                reject(failure);
-            }
-            else
+        const child = execFile('git', ['-C', folder, '-c', 'core.fsmonitor=false', '-c', 'core.untrackedCache=false', '-c', 'core.hooksPath=/dev/null', ...args], { encoding: 'utf8', timeout: 30_000, maxBuffer: 4 << 20, signal, env: { ...process.env, GIT_TERMINAL_PROMPT: '0', GIT_OPTIONAL_LOCKS: '0' } }, (error, stdout, stderr) => {
+            if (!error) {
                 resolve(stdout);
+                return;
+            }
+            if (signal?.aborted) {
+                const abortError = error;
+                reject(abortError);
+                return;
+            }
+            const failure = new GitError(folder, Object.assign(error, { stderr }));
+            Object.assign(failure, { stdout });
+            reject(failure);
         });
         child.stdin?.on('error', () => undefined); // Early Git refusal is reported by the callback.
         child.stdin?.end(input);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shardflux/cli",
-  "version": "0.14.1",
+  "version": "0.14.2",
   "type": "module",
   "description": "shard: the Shardflux command line. Create an account, sign in, set up keys and billing, then open, run commands in, move files to, suspend, resume and fork serverless agent workspaces.",
   "license": "Apache-2.0",