sideby 0.9.2 → 0.9.3

package/dist/build.json

@@ -1 +1 @@
-{"id":"20261015T120149-abb6bb"}
+{"id":"20261015T124638-3ce884"}

package/dist/src/core/handoff-chain.d.ts

@@ -18,6 +18,8 @@ export interface PlanFile {
     threshold: number;
     /** False when the session cannot write its Brief: no preparing step, and the threshold only ends the turn. */
     agentBrief?: boolean;
+    /** The parent reads `to` from a manual request; a parent from before 0.9.3 does not write it and ignores `to`. */
+    acceptsTo?: true;
 }
 /** What the hook already did in one run. */
 export interface RunState {

package/dist/src/core/handoff-run.js

@@ -8,6 +8,7 @@ import { join } from 'node:path';
 import { HOOK_FAMILIES } from '../handoff/hook.js';
 import { firstPrompt } from '../handoff/messages.js';
 import { aliasArgs } from './config.js';
+import { UserError } from './errors.js';
 import { finishBrief } from './handoff-brief.js';
 import { briefPath, chainDir, ensureChainDir, FILES, HANDOFF_ENV, newId, readJsonFile, writeJsonFile, } from './handoff-chain.js';
 import { runHost, sidebyBinProblem, spawnHost } from './launch.js';
@@ -232,6 +233,7 @@ opts = {}) {
                         prepareAt: settings.prepareAt,
                         threshold: settings.threshold,
                         ...(elig.agentBrief === false ? { agentBrief: false } : {}),
+                        acceptsTo: true,
                     };
                     await writeJsonFile(join(dir, FILES.plan), plan);
                 }
@@ -347,6 +349,11 @@ export async function readyDecision(rt, env, to) {
     const ref = env.SIDEBY_ACCOUNT;
     if (!env[HANDOFF_ENV.run] || !dir || !ref)
         return null;
+    if (to !== undefined) {
+        const plan = await readJsonFile(join(dir, FILES.plan));
+        if (plan && plan.runId === env[HANDOFF_ENV.run] && !plan.acceptsTo)
+            throw new UserError(`this session was started by an older sideby, which cannot hand over to a named account; exit it and start ${to} yourself (\`sideby run ${to}\`), or run \`sideby handoff ready\` without --to`, { code: 'parent-too-old' });
+    }
     const account = await rt.resolve(ref);
     const chain = await readJsonFile(join(dir, FILES.chain));
     return decide(rt, account, chain?.hops.map((h) => h.ref) ?? [account.ref], to);

package/dist/src/families/claude/handoff.js

@@ -85,6 +85,7 @@ export const claudeHandoff = {
         ];
         const settings = {
             hooks: {
+                SessionStart: hook('SessionStart'),
                 PostToolUse: hook('PostToolUse'),
                 Stop: hook('Stop'),
                 StopFailure: [

package/dist/src/handoff/hook.js

@@ -7,7 +7,7 @@ import { FILES, HANDOFF_ENV, readJsonFile, writeJsonFile, } from '../core/handof
 import { claudeHookReader } from '../families/claude/handoff-hook.js';
 import { codexHookReader } from '../families/codex/handoff-hook.js';
 import { grokHookReader } from '../families/grok/handoff-hook.js';
-import { endTurnMessage, prepareMessage, stopMessage, thresholdMessage } from './messages.js';
+import { endTurnMessage, prepareMessage, sessionStartMessage, stopMessage, thresholdMessage, } from './messages.js';
 import { field } from './reader.js';
 export const HOOK_COMMAND = 'sideby handoff-hook';
 const READERS = {
@@ -17,7 +17,7 @@ const READERS = {
 };
 /** Families whose hooks this entry understands; only they can start a Handoff. */
 export const HOOK_FAMILIES = Object.keys(READERS);
-const EVENTS = new Set(['PostToolUse', 'Stop', 'StopFailure']);
+const EVENTS = new Set(['SessionStart', 'PostToolUse', 'Stop', 'StopFailure']);
 async function readAll(stream) {
     const chunks = [];
     try {
@@ -29,8 +29,8 @@ async function readAll(stream) {
     }
     return Buffer.concat(chunks).toString('utf8');
 }
-const contextOutput = (text) => ({
-    hookSpecificOutput: { hookEventName: 'PostToolUse', additionalContext: text },
+const contextOutput = (text, hookEventName = 'PostToolUse') => ({
+    hookSpecificOutput: { hookEventName, additionalContext: text },
 });
 const blockOutput = (reason) => ({ decision: 'block', reason });
 async function mtimeMs(path) {
@@ -67,6 +67,14 @@ export async function decide(opts) {
             return;
         await writeJsonFile(readyFile, { runId, at: now.toISOString(), ...session, ...r });
     };
+    // The session learns it may move the task on when the user asks; without this it tells the user to start the
+    // other account by hand.
+    if (event === 'SessionStart') {
+        const ref = env.SIDEBY_ACCOUNT;
+        return ref && usable
+            ? { output: contextOutput(sessionStartMessage(ref, usable.brief), 'SessionStart') }
+            : {};
+    }
     const threshold = usable?.threshold ?? 95;
     const pressure = reader.pressure ? await reader.pressure(input, env, now) : null;
     if (event === 'StopFailure') {

package/dist/src/handoff/messages.d.ts

@@ -3,6 +3,8 @@ export declare function thresholdMessage(brief: string, pressure: number): strin
 /** At the threshold when the session cannot write a Brief: sideby puts one together from its records. */
 export declare function endTurnMessage(pressure: number): string;
 export declare function stopMessage(brief: string): string;
+/** At session start (Claude): this session may hand its task to another account when the user asks. */
+export declare function sessionStartMessage(ref: string, brief: string): string;
 declare const WHY: {
     readonly threshold: 'its quota ran low';
     readonly limit: 'its quota ran out';

package/dist/src/handoff/messages.js

@@ -21,6 +21,10 @@ export function endTurnMessage(pressure) {
 export function stopMessage(brief) {
     return `sideby: before you stop, update the handoff brief at ${brief} (${TEMPLATE}; ${RULES}), then end your turn.`;
 }
+/** At session start (Claude): this session may hand its task to another account when the user asks. */
+export function sessionStartMessage(ref, brief) {
+    return `sideby: this session runs in ${ref} under sideby with Auto Handoff. If the user wants this task to go on in another account ("continue in cc008", "hand it back to cc008"), do not ask them to start that account: write a handoff brief to ${brief} (${TEMPLATE}; ${RULES}), run \`sideby handoff ready --to <account>\` (an account or short command), tell the user the account it prints, and end your turn. sideby then ends this session and starts that account in this terminal.`;
+}
 const WHY = {
     threshold: 'its quota ran low',
     limit: 'its quota ran out',

package/dist/src/types.d.ts

@@ -112,7 +112,7 @@ export interface FamilyDef {
     handoff?: FamilyHandoff;
 }
 /** A Host hook event sideby's handoff hook listens to. */
-export type HandoffHookEvent = 'PostToolUse' | 'Stop' | 'StopFailure';
+export type HandoffHookEvent = 'SessionStart' | 'PostToolUse' | 'Stop' | 'StopFailure';
 /** Whether one run may start a Handoff, or start as the next Account of one, and why not. */
 export interface HandoffEligibility {
     start: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sideby",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "description": "Run work, personal and API-key accounts at the same time, without their configs drifting apart.",
   "license": "MIT",
   "author": "Adonis0123 (https://github.com/Adonis0123)",

package/skills/sideby/SKILL.md

@@ -1,8 +1,8 @@
 ---
 name: sideby
-description: Use when the user runs, or wants to run, several AI coding accounts (Claude Code, Codex, Grok Build, pi) side by side. Covers installing sideby and setting up a new account ("install sideby", "set up another Claude account", "add cc008", "配置一个 cc00x", "再加一个 Codex 账号"), explaining what accounts share and what stays separate ("what do my accounts share?", "这些账号共享了什么"), showing which account a session is ("show [cc001] in the status line", "加上账号标识"), seeing accounts, quota and usage, moving on when one hits its 5-hour or weekly limit, adding a short command (alias), and repairing drifted account directories (skills, hooks, rules or settings not shared, wrong symlinks, credential file permissions). Drives the `sideby` CLI with `--json`; the agent does every step except browser sign-in, filling in secrets and starting interactive sessions, which it hands to the user as one command.
+description: Use when the user runs, or wants to run, several AI coding accounts (Claude Code, Codex, Grok Build, pi) side by side. Covers installing sideby and setting up a new account ("install sideby", "set up another Claude account", "add cc008", "配置一个 cc00x", "再加一个 Codex 账号"), explaining what accounts share and what stays separate ("what do my accounts share?", "这些账号共享了什么"), showing which account a session is ("show [cc001] in the status line", "加上账号标识"), seeing accounts, quota and usage, moving on when one hits its 5-hour or weekly limit, moving the current task to another account ("用 cc008 继续", "交回 cc008"), adding a short command (alias), and repairing drifted account directories (skills, hooks, rules or settings not shared, wrong symlinks, credential file permissions). Drives the `sideby` CLI with `--json`; the agent does every step except browser sign-in, filling in secrets and starting interactive sessions, which it hands to the user as one command (inside an Auto Handoff session, `sideby handoff ready --to` moves the task itself).
 metadata:
-  version: "0.9.2"
+  version: "0.9.3"
   requires:
     bins: [sideby, node]
   cliHelp: sideby --help
@@ -20,7 +20,7 @@ Do every step you can yourself. Only browser sign-in, secrets and interactive se
 - **Never sign in for the user.** Give them `sideby login <ref>` as one line to run in their own terminal (Claude Code: `! sideby login <ref>`). OAuth needs their browser and their decision.
 - **Never put a secret on the command line or in chat.** For API accounts, the user edits `proxy.env` themselves.
 - **Never start a Host session from your shell.** `sideby run`, `sideby next` (without `--dry-run`) and `sideby login` open an interactive session; give the user the command instead.
-- **Never switch, rotate or proxy accounts yourself.** Do not work around sideby by editing config, copying session files or moving credentials. `sideby next` only recommends. Moving a running task on its own is Auto Handoff, which the user turns on: use `sideby handoff enable` (exit 10, then their yes), never hand-edit `config.json`. Inside such a session you may run `sideby handoff ready` when the user asks to hand over.
+- **Never switch, rotate or proxy accounts yourself.** Do not work around sideby by editing config, copying session files or moving credentials. `sideby next` only recommends. Moving a running task on its own is Auto Handoff, which the user turns on: use `sideby handoff enable` (exit 10, then their yes), never hand-edit `config.json`. Inside such a session (the environment has `SIDEBY_HANDOFF_RUN`), when the user wants the task to go on in another account ("用 cc008 继续", "交回 cc008"), do not hand them a command to start it: update the brief, run `sideby handoff ready --to <account>`, tell them the account it prints, and end your turn; sideby starts that account in the same terminal.
 - **Say what you change.** Read-only commands first. What the user asked for (the account they asked to create, its short command, the shell line that makes it work) you do, saying what you do. Changes they did not ask for (`doctor --fix` on other accounts, `quota setup`, `app install`) wait until they have seen the change and agreed.
 - Do not edit Host config files (`settings.json`, `config.toml`, symlinks in account directories) by hand when a `sideby` command does the job.