@voidlabs.gg/voidshift 0.4.5 → 0.4.7

package/README.md

@@ -74,9 +74,9 @@ or `vs-parked`) and the round (`vs-v1`, `vs-v2`). On Linear it posts the plan an
 one final comment, nothing in between.
 
 ```sh
-vsf agents status                  # runner, the card in progress, parked cards
+vsf agents status                  # runner, the card each workspace is on, parked cards
 vsf agents run ENG-123 [--from qa] # run one card now, in this terminal
-vsf agents start | stop | restart  # the background runner (stop cancels the card)
+vsf agents start | stop | restart  # the background runner (stop cancels its cards)
 vsf agents pause | resume          # pick up no new cards for a while
 vsf agents cancel | retry ENG-123  # stop a card, or queue a parked one again
 vsf agents runs | show ENG-123     # what happened, step by step
@@ -84,11 +84,25 @@ vsf agents logs [ENG-123] [-f]     # the runner log, or a card's step logs
 vsf agents workflows               # workflows in the order they match
 vsf agents workflow add|edit|show|rename|move|rm
 vsf agents projects | project add|edit|show|rename|rm
+vsf agents workspace add|list|rm   # folders of repos, each with its own queue
 vsf agents homes | link DIR        # where the agents are installed
 vsf agents clean                   # old worktrees and run logs
 vsf agents validate [DIR]          # check the config and agent folders
 ```
 
+Each workspace has one queue: cards in different workspaces run side by side,
+two cards in one workspace one after the other. Projects are in the `default`
+workspace until you move them:
+
+```sh
+vsf agents workspace add solvia --root ~/work/solvia   # steps carry ~/work/solvia/CONTEXT.md
+vsf agents project edit erp --workspace solvia --match DS06
+```
+
+`--match` names a tracker project (or its first word, so `DS06` matches "DS06
+Atleurope ERP"). A card of that project runs in the matching project, in any
+workspace, before the workflow's own project is considered.
+
 A workflow can also be a folder you write by hand,
 `~/.config/voidshift/agents/defs/NAME/agent.json`, with its prompt files next to
 it. Steps are the built-in ids above or your own:
@@ -127,9 +141,18 @@ vsf memory status          # the vault and where recall is on
 vsf memory search WORDS    # notes recall would bring up
 vsf memory try "a prompt"  # exactly what recall would add to that prompt
 vsf memory check           # notes missing from INDEX.md, broken links
+vsf memory sync            # pull and push the vault through its git remote
 vsf memory on | off        # turn recall on or off
 ```
 
+To share the vault between machines, make it a git repository with a remote
+named `origin` (any host; a private repository). `vsf memory sync` commits new
+notes, rebases onto the remote and pushes. It also runs in the background from
+the recall hook when the last sync is over ten minutes old, and the agents
+runner syncs before and after every run. When a note changed on both sides,
+the remote's version stays and this machine's copy is saved beside it as
+`note.conflict-<machine>-<time>.md`, so nothing is lost.
+
 Setup creates a vault at `~/memory` or uses one you already have. Codex asks you
 to trust the recall hook once: run `/hooks` in Codex.
 
@@ -180,8 +203,12 @@ pnpm test
 node packages/cli/src/main.ts
 ```
 
-Node 22.18 or newer runs the TypeScript sources directly. Releases are cut by
-pushing a `v*` tag; CI publishes every package at that version.
+Node 22.18 or newer runs the TypeScript sources directly. Each package
+releases on its own: bump its `package.json` and push `agents-v0.5.0` (or
+`cli-v`, `memory-v`, `awake-v`), and CI publishes only that package. A plain
+`v*` tag publishes all four at one version. Tools declare the CLI contract
+they were built for; a CLI that is too old refuses to load them and says to
+run `vsf update`.
 
 ## License
 

package/dist/loader.d.ts

@@ -1,5 +1,5 @@
 import type { ToolEntry } from './registry.ts';
-import type { Tool } from './tool.ts';
+import { type Tool } from './tool.ts';
 export declare function locate(entry: ToolEntry, configDir: string): string | null;
 export declare function npm(args: string[]): boolean;
 export declare function fetchTool(entry: ToolEntry, configDir: string): boolean;

package/dist/loader.js

@@ -10,6 +10,7 @@ import { spawnSync } from 'node:child_process';
 import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { fileURLToPath, pathToFileURL } from 'node:url';
+import { CONTRACT } from "./tool.js";
 // Inside the monorepo, tools load straight from source. Installed copies
 // live under <configDir>/tools, one npm prefix shared by every tool.
 function sourcePath(entry) {
@@ -47,5 +48,8 @@ export async function loadTool(entry, configDir) {
     if (!path)
         throw new Error(`could not download ${entry.pkg}. Check your connection and run vsf setup again.`);
     const mod = (await import(__rewriteRelativeImportExtension(pathToFileURL(path).href)));
+    const contract = mod.default.contract ?? 1;
+    if (contract > CONTRACT)
+        throw new Error(`${entry.name} needs a newer vsf (it uses tool contract ${contract}, this vsf knows ${CONTRACT}). Run vsf update.`);
     return mod.default;
 }

package/dist/tool.d.ts

@@ -37,9 +37,11 @@ export interface ToolContext {
     ui: Ui;
 }
 export type ToolCommand = (args: string[], ctx: ToolContext) => Promise<number>;
+export declare const CONTRACT = 1;
 export interface Tool {
     name: string;
     summary: string;
+    contract?: number;
     install(ctx: ToolContext): Promise<void>;
     uninstall(ctx: ToolContext): Promise<void>;
     checks(ctx: ToolContext): Promise<Check[]>;

package/dist/tool.js

@@ -1,4 +1,6 @@
 // The contract every voidshift tool implements. The CLI owns discovery,
 // install and reporting; a tool only knows how to set itself up, take
 // itself down, say whether it is healthy, and run its own subcommands.
-export {};
+// The version of this contract. A tool built for a newer one may call things
+// this CLI does not have, so it is not loaded; tools without the field are 1.
+export const CONTRACT = 1;

package/dist/tui/data.d.ts

@@ -13,6 +13,7 @@ export interface AgentsCurrent {
     runDir?: string;
     checking?: boolean;
     elapsedMinutes?: number;
+    workspace?: string;
 }
 export interface AgentsStatus {
     engine?: string;
@@ -22,6 +23,7 @@ export interface AgentsStatus {
         line: string;
     } | null;
     current: AgentsCurrent | null;
+    running?: AgentsCurrent[];
     parked: {
         card: string;
         reason?: string;
@@ -30,6 +32,7 @@ export interface AgentsStatus {
     workflows: number;
     projects: number;
 }
+export declare const liveRunsOf: (agents: AgentsStatus | null | undefined) => AgentsCurrent[];
 export interface StepRecord {
     step: string;
     label: string;

package/dist/tui/data.js

@@ -22,6 +22,8 @@ import { CLI_PKG, cliVersion, isNewer } from "../version.js";
 const h = React.createElement;
 export const POLL_MS = 2000;
 export const CHECKS_MS = 30_000;
+// The runs going on now, whichever shape the agents tool printed.
+export const liveRunsOf = (agents) => agents?.running ?? (agents?.current?.card ? [agents.current] : []);
 export function emptyState(tools = []) {
     return {
         version: cliVersion(),

package/dist/tui/home.d.ts

@@ -10,6 +10,7 @@ export declare function nextSection(sections: SectionId[], current: SectionId, d
 export declare const clampFocus: (sections: SectionId[], current: SectionId) => SectionId;
 export interface LiveCard {
     card: string;
+    workspace?: string;
     title: string;
     workflow: string;
     step: string;
@@ -18,7 +19,9 @@ export interface LiveCard {
     maxRounds: number | null;
     steps: StepProgress[];
 }
-export declare function liveCard(state: Pick<DataState, 'agents' | 'runs' | 'workflows' | 'steps' | 'agentsConfig'>, nowMs: number): LiveCard | null;
+type LiveState = Pick<DataState, 'agents' | 'runs' | 'workflows' | 'steps' | 'agentsConfig'>;
+export declare function liveCards(state: LiveState, nowMs: number): LiveCard[];
+export declare const liveCard: (state: LiveState, nowMs: number) => LiveCard | null;
 export declare function runnerLines(agents: AgentsStatus, nowMs: number): {
     left: Line;
     right: Line;
@@ -49,3 +52,4 @@ export declare function homeHints(opts: {
 }): Hint[];
 export declare const homeScreen: Screen;
 export declare function Home(): React.ReactElement;
+export {};

package/dist/tui/home.js

@@ -3,7 +3,7 @@
 // shaping of the store's data into lines (tested); the component below draws them.
 import React, { useEffect, useState } from 'react';
 import { Box, Text } from 'ink';
-import { useData, runsThisWeek, updateNotice } from "./data.js";
+import { liveRunsOf, useData, runsThisWeek, updateNotice } from "./data.js";
 import { useHints, useKeys, useScreen } from "./context.js";
 import { clock, clockOrStamp, duration, minutesText, plural, secondsToNextCheck, tilde, truncate } from "./format.js";
 import { theme } from "./theme.js";
@@ -31,10 +31,18 @@ const titleCase = (id) => {
     const t = id.replace(/^vs-/, '').replace(/-/g, ' ');
     return t.charAt(0).toUpperCase() + t.slice(1);
 };
-// The card being worked on, with the progress of each step of its workflow.
-export function liveCard(state, nowMs) {
-    const current = state.agents?.current;
-    if (!current || !current.card)
+// The cards being worked on, one per busy workspace, in workspace order.
+export function liveCards(state, nowMs) {
+    return liveRunsOf(state.agents)
+        .map((c) => liveCardOf(c, state, nowMs))
+        .filter((c) => !!c)
+        .sort((a, b) => (a.workspace ?? '').localeCompare(b.workspace ?? ''));
+}
+// The first card being worked on.
+export const liveCard = (state, nowMs) => liveCards(state, nowMs)[0] ?? null;
+// A card being worked on, with the progress of each step of its workflow.
+function liveCardOf(current, state, nowMs) {
+    if (!current.card)
         return null;
     const run = state.runs.find((r) => r.card === current.card && r.record?.outcome === 'running' && (!current.runDir || r.dir === current.runDir));
     const rec = run?.record;
@@ -67,11 +75,13 @@ export function liveCard(state, nowMs) {
     const startedAt = Date.parse(current.startedAt ?? rec?.startedAt ?? '');
     return {
         card: current.card,
+        workspace: current.workspace,
         title: current.title ?? rec?.title ?? '',
         workflow: current.workflow ?? rec?.workflow ?? '',
         step: current.step ?? '',
         minutes: current.elapsedMinutes ?? (Number.isNaN(startedAt) ? 0 : Math.max(0, Math.round((nowMs - startedAt) / 60_000))),
-        round: (current.round ?? 0) + 1,
+        // The lock's round is 1-based like the card's label; 0 before the first.
+        round: current.round || 1,
         maxRounds: workflow?.maxRounds ?? null,
         steps,
     };
@@ -291,19 +301,19 @@ function AgentsPanel(props) {
     if (!agents)
         return h(Panel, { title: 'Agents', focused: props.focused }, toolState(state.errors.agents));
     const run = runnerLines(agents, props.now);
-    const live = liveCard(state, props.now);
+    const lives = liveCards(state, props.now);
     const parked = parkedRows(agents);
     const rows = [h(SplitRow, { key: 'runner', left: run.left, right: run.right })];
-    if (live) {
-        rows.push(h(Text, { key: 'g1' }, ' '));
+    for (const live of lives) {
+        rows.push(h(Text, { key: `g1${live.card}` }, ' '));
         rows.push(h(SplitRow, {
-            key: 'live',
+            key: `live${live.card}`,
             left: [seg('▶ ', theme.accent), seg(live.card, theme.accent, { bold: true }), seg(`  ${truncate(live.title, 60)}`)],
-            right: [seg(live.workflow, theme.dim)],
+            right: [seg(live.workspace && live.workspace !== 'default' ? `${live.workspace} · ${live.workflow}` : live.workflow, theme.dim)],
         }));
-        rows.push(h(Box, { key: 'steps', flexDirection: 'row' }, h(Text, null, '  '), h(ProgressSteps, { steps: live.steps }), h(Text, { color: theme.dim }, `       running ${duration(live.minutes * 60_000)}${live.maxRounds ? ` · round ${live.round} of ${live.maxRounds}` : ` · round ${live.round}`}`)));
+        rows.push(h(Box, { key: `steps${live.card}`, flexDirection: 'row' }, h(Text, null, '  '), h(ProgressSteps, { steps: live.steps }), h(Text, { color: theme.dim }, `       running ${duration(live.minutes * 60_000)}${live.maxRounds ? ` · round ${live.round} of ${live.maxRounds}` : ` · round ${live.round}`}`)));
     }
-    else if (agents.current) {
+    if (!lives.length && agents.current) {
         rows.push(h(Text, { key: 'g1' }, ' '));
         rows.push(h(Text, { key: 'checking', color: theme.dim }, '  Checking Linear now.'));
     }

package/dist/tui/palette.js

@@ -8,7 +8,7 @@ import { Box, Text, useInput } from 'ink';
 import { needsTerminal } from "./actions.js";
 import { editText, Panel } from "./widgets.js";
 import { theme } from "./theme.js";
-import { useData } from "./data.js";
+import { liveRunsOf, useData } from "./data.js";
 const h = React.createElement;
 // Splits "agents retry 'ENG 1'" into words. Quotes group words.
 export function splitCommand(text) {
@@ -113,9 +113,9 @@ export function dynamicEntries(state) {
         add(`agents retry ${p.card}`, 'queue the parked card again');
     for (const c of state.agents?.interrupted ?? [])
         add(`agents retry ${c}`, 'queue the interrupted card again');
-    const live = state.agents?.current?.card;
-    if (live)
-        add(`agents cancel ${live}`, 'stop the card being worked on');
+    for (const live of liveRunsOf(state.agents))
+        if (live.card)
+            add(`agents cancel ${live.card}`, 'stop the card being worked on');
     const cards = new Set();
     for (const r of state.runs) {
         if (cards.size >= 6 && !cards.has(r.card))

package/dist/tui/screens/log.js

@@ -9,7 +9,7 @@ import { useHints, useKeys, useScreen } from "../context.js";
 import { useData } from "../data.js";
 import { Lines, Panel, seg } from "../widgets.js";
 import { theme } from "../theme.js";
-import { cancelSpec, isLive, settledSteps, stepDuration, stepMark } from "./runs.js";
+import { cancelSpec, liveRunFor, settledSteps, stepDuration, stepMark } from "./runs.js";
 const h = React.createElement;
 export const POLL_LOG_MS = 500;
 const MAX_LINES = 5000;
@@ -162,7 +162,8 @@ export function LogView(props) {
     const card = String(props.params.card ?? '');
     const dir = typeof props.params.dir === 'string' ? props.params.dir : null;
     const run = state.runs.find((r) => (dir ? r.dir === dir : r.card === card));
-    const live = isLive(run, state);
+    const cur = liveRunFor(run, state);
+    const live = !!cur;
     const record = run?.record;
     const [picked, setPicked] = useState(null);
     const [scroll, setScroll] = useState({ top: null });
@@ -216,7 +217,7 @@ export function LogView(props) {
             if (!live)
                 ctx.toast(`${card} is not running, so there is nothing to cancel.`, 'info');
             else
-                void ctx.actions.run(cancelSpec(card, state.agents?.current?.step));
+                void ctx.actions.run(cancelSpec(card, cur?.step));
         }
     });
     if (!run) {
@@ -232,8 +233,8 @@ export function LogView(props) {
     if (!steps.length)
         left.push([seg('No steps yet', theme.dim)]);
     const workflow = state.workflows.find((w) => w.name === record?.workflow);
-    const cur = state.agents?.current;
-    const round = live && cur?.round !== undefined ? cur.round + 1 : Math.max(1, steps.filter((s) => s.step === steps[0]?.step).length);
+    // The lock's round is 1-based like the card's label; 0 before the first.
+    const round = cur?.round ? cur.round : Math.max(1, steps.filter((s) => s.step === steps[0]?.step).length);
     left.push([], [seg(`round ${round}${workflow?.maxRounds ? ` of ${workflow.maxRounds}` : ''}`, theme.dim)], []);
     run.logs.forEach((l) => {
         const on = l === file;

package/dist/tui/screens/runs.d.ts

@@ -1,7 +1,7 @@
 import React from 'react';
 import { type Key } from 'ink';
 import { type ActionSpec, type Hint } from '../context.ts';
-import { type DataState, type RunItem, type StepRecord } from '../data.ts';
+import { type AgentsCurrent, type DataState, type RunItem, type StepRecord } from '../data.ts';
 import { type Line } from '../widgets.ts';
 import type { Screen } from '../screens.ts';
 export declare const manualLogPath: (dir: string) => string;
@@ -13,7 +13,8 @@ export declare function stepsLabel(steps: StepRecord[]): string;
 export declare function roundsOf(steps: StepRecord[]): number;
 export declare function runMs(run: RunItem, nowMs: number): number | null;
 export declare function outcomeOf(run: RunItem, state: Pick<DataState, 'agents'>): string;
-export declare function isLive(run: RunItem | undefined, state: Pick<DataState, 'agents'>): boolean;
+export declare function liveRunFor(run: RunItem | undefined, state: Pick<DataState, 'agents'>): AgentsCurrent | undefined;
+export declare const isLive: (run: RunItem | undefined, state: Pick<DataState, "agents">) => boolean;
 export declare function startedText(run: RunItem): string;
 export declare function settledSteps(run: RunItem, state: Pick<DataState, 'agents'>): StepRecord[];
 export declare function stepMark(step: StepRecord): {

package/dist/tui/screens/runs.js

@@ -7,7 +7,7 @@ import { join } from 'node:path';
 import { configDir } from "../../config.js";
 import { runAction } from "../actions.js";
 import { useBackGuard, useEquivalent, useHints, useKeys, useScreen } from "../context.js";
-import { useData } from "../data.js";
+import { liveRunsOf, useData } from "../data.js";
 import { duration, folderStamp, stamp, tilde, truncate } from "../format.js";
 import { Lines, Panel, Select, Table, TextInput, outcomeColour, seg } from "../widgets.js";
 import { theme } from "../theme.js";
@@ -48,22 +48,23 @@ export function runMs(run, nowMs) {
     const end = rec.endedAt ? Date.parse(rec.endedAt) : nowMs;
     return Math.max(0, end - start);
 }
-// The outcome shown for a run. A run that says "running" while the runner is
-// busy with something else was cut off.
+// The outcome shown for a run. A run that says "running" while no live run
+// is on its card was cut off.
 export function outcomeOf(run, state) {
     const outcome = run.record?.outcome;
     if (!outcome)
         return 'old run';
-    if (outcome === 'running' && state.agents && state.agents.current?.card !== run.card)
+    if (outcome === 'running' && state.agents && !liveRunsOf(state.agents).some((c) => c.card === run.card))
         return 'interrupted';
     return outcome;
 }
-export function isLive(run, state) {
+// The live run working on this run, if any.
+export function liveRunFor(run, state) {
     if (!run || run.record?.outcome !== 'running')
-        return false;
-    const cur = state.agents?.current;
-    return !!cur && cur.card === run.card && (!cur.runDir || cur.runDir === run.dir);
+        return undefined;
+    return liveRunsOf(state.agents).find((cur) => cur.card === run.card && (!cur.runDir || cur.runDir === run.dir));
 }
+export const isLive = (run, state) => !!liveRunFor(run, state);
 export function startedText(run) {
     const t = run.record ? Date.parse(run.record.startedAt) : NaN;
     return Number.isNaN(t) ? folderStamp(run.stamp) : stamp(new Date(t));
@@ -235,7 +236,7 @@ export function Runs(props) {
     const isLatest = !!run && state.runs.find((r) => r.card === run.card)?.dir === run.dir;
     const labels = useLabels(isLatest && record ? run.card : undefined);
     const live = isLive(run, state);
-    const liveStep = state.agents?.current?.step;
+    const liveStep = liveRunFor(run, state)?.step;
     const workflow = state.workflows.find((w) => w.name === record?.workflow);
     const stepIds = workflow?.steps ?? [...new Set((record?.steps ?? []).map((s) => s.step))];
     const labelOf = (id) => state.steps?.steps.find((s) => s.id === id)?.label ?? record?.steps.find((s) => s.step === id)?.label ?? id;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voidlabs.gg/voidshift",
-  "version": "0.4.5",
+  "version": "0.4.7",
   "description": "One CLI for the Void dev tools: keep your Mac awake, run agents in the background, shared skills and memory for Claude Code and Codex.",
   "license": "Apache-2.0",
   "repository": {
@@ -41,7 +41,7 @@
   "scripts": {
     "build": "rm -rf dist && tsc -p tsconfig.json",
     "typecheck": "tsc -p tsconfig.json --noEmit",
-    "test": "node --test test/*.test.ts",
+    "test": "node --test --test-force-exit --test-timeout=60000 test/*.test.ts",
     "dev": "node src/main.ts",
     "prepublishOnly": "rm -rf dist && tsc -p tsconfig.json"
   },