@zergai/ztc 0.4.0-beta.1 → 0.5.0-beta.1

package/dist/agent/commands/permissions.js

@@ -1,94 +1,84 @@
-const ALL_CAPS = ['file_read', 'file_write', 'shell_exec', 'network'];
-function normalize(value) {
-    return value.trim().toLowerCase();
+import { DEFAULT_PERMISSION_PROFILES } from '../../config.js';
+import { PERMISSION_CAPABILITIES, describePermissionChanges, describePermissionPolicy, projectPermissionPolicy, readRepoPermissionProfiles } from '../../config/permissions.js';
+const usage = '/permissions show | profiles [--repo] | use <profile|repo:name> | set <capability> <on|off>';
+const normalize = (value) => value.trim().toLowerCase();
+export async function activatePermissionConfig(next, ctx) {
+    if (ctx.commandOrigin === 'agent')
+        throw new Error('Permission changes require an explicit user command.');
+    const previous = ctx.config.get(), after = projectPermissionPolicy(next);
+    if (after.commandSandbox.required && after.commandSandbox.enforcement !== 'os') {
+        throw new Error(`OS command sandbox required but unavailable for ${after.id}; profile unchanged. ${describePermissionPolicy(after)}`);
+    }
+    let change;
+    try {
+        change = describePermissionChanges(projectPermissionPolicy(previous), after);
+    }
+    catch {
+        change = `Previous permission profile was invalid.\n${describePermissionPolicy(after)}`;
+    }
+    try {
+        ctx.config.set('permissionProfiles', next.permissionProfiles);
+        ctx.config.set('toolPermissions', next.toolPermissions);
+        ctx.config.set('permissionProfile', next.permissionProfile);
+        ctx.config.set('sandbox', next.sandbox);
+        await ctx.reloadAgent();
+        await ctx.config.save();
+    }
+    catch (error) {
+        ctx.config.set('permissionProfiles', previous.permissionProfiles);
+        ctx.config.set('toolPermissions', previous.toolPermissions);
+        ctx.config.set('permissionProfile', previous.permissionProfile);
+        ctx.config.set('sandbox', previous.sandbox);
+        await ctx.reloadAgent();
+        throw error;
+    }
+    return `Permission profile active: ${after.id}\n${change}`;
 }
-export const permissionsCommand = {
-    name: 'permissions',
-    description: 'View or update tool permissions',
-    usage: {
-        default: '<show|set|profiles|use>',
-        variants: [
-            { when: { 0: ['set'] }, usage: '<show|set|profiles|use> <capability> <on|off>' },
-            { when: { 0: ['use'] }, usage: '<show|set|profiles|use> <profile>' },
-        ],
-    },
-    handler: async (args, ctx) => {
-        const subCmd = normalize(args[0] || 'show');
-        const config = ctx.config.get();
-        const current = config.toolPermissions || {};
-        if (subCmd === 'show') {
-            const lines = ALL_CAPS.map(cap => {
-                const value = current[cap];
-                const label = value === false ? 'off' : 'on';
-                return `  ${cap}: ${label}`;
-            });
-            const profile = config.permissionProfile || 'trusted';
-            ctx.addMessage({
-                role: 'system',
-                content: [`Tool permissions:`, `  profile: ${profile}`, ...lines].join('\n')
-            });
-            return;
-        }
-        if (subCmd === 'profiles') {
-            const profiles = config.permissionProfiles || {};
-            const lines = Object.entries(profiles).map(([id, profile]) => {
-                const marker = id === config.permissionProfile ? '*' : ' ';
-                return `${marker} ${id}: ${profile.description || 'No description'}`;
-            });
-            ctx.addMessage({
-                role: 'system',
-                content: ['Permission profiles:', ...lines].join('\n')
-            });
-            return;
+async function run(args, ctx) {
+    const action = normalize(args[0] ?? 'show'), config = ctx.config.get();
+    if (['use', 'set'].includes(action) && ctx.commandOrigin === 'agent')
+        return 'Permission changes require an explicit user command.';
+    if (action === 'show')
+        return args.length > 1 ? usage : describePermissionPolicy(projectPermissionPolicy(config));
+    if (action === 'profiles') {
+        if (args.length > 2 || (args.length === 2 && args[1] !== '--repo'))
+            return usage;
+        const repo = args[1] === '--repo';
+        const profiles = repo ? await readRepoPermissionProfiles(ctx.shell.getCwd()) : { ...DEFAULT_PERMISSION_PROFILES, ...config.permissionProfiles };
+        return ['Permission profiles (policy checks; not session-wide OS isolation):', ...Object.entries(profiles).map(([id, profile]) => `${(repo ? `repo:${id}` : id) === config.permissionProfile ? '*' : ' '} ${repo ? `repo:${id}` : id}: ${profile.description ?? 'Custom capability/path/command policy'}`)].join('\n');
+    }
+    if (action === 'use') {
+        if (args.length !== 2)
+            return usage;
+        const id = normalize(args[1]);
+        let profiles = { ...DEFAULT_PERMISSION_PROFILES, ...config.permissionProfiles };
+        if (id.startsWith('repo:')) {
+            const imported = await readRepoPermissionProfiles(ctx.shell.getCwd());
+            const profile = imported[id.slice(5)];
+            if (!profile)
+                return `Unknown repo permission profile: ${id}. Use /permissions profiles --repo.`;
+            profiles = { ...profiles, [id]: profile };
         }
-        if (subCmd === 'use') {
-            const profile = normalize(args[1] || '');
-            if (!profile || !config.permissionProfiles?.[profile]) {
-                ctx.addMessage({
-                    role: 'system',
-                    content: 'Usage: /permissions use <profile>. Run /permissions profiles to list available profiles.'
-                });
-                return;
-            }
-            ctx.config.set('permissionProfile', profile);
-            await ctx.config.save();
-            ctx.reloadAgent();
-            ctx.addMessage({
-                role: 'system',
-                content: `✓ Permission profile active: ${profile}`
-            });
-            return;
+        if (!Object.hasOwn(profiles, id))
+            return `Unknown permission profile: ${id}. Use /permissions profiles.`;
+        return activatePermissionConfig({ ...config, permissionProfile: id, permissionProfiles: profiles }, ctx);
+    }
+    if (action === 'set') {
+        const cap = normalize(args[1] ?? ''), value = normalize(args[2] ?? '');
+        if (args.length !== 3 || !PERMISSION_CAPABILITIES.includes(cap) || !['on', 'off'].includes(value))
+            return usage;
+        return activatePermissionConfig({ ...config, toolPermissions: { ...config.toolPermissions, [cap]: value === 'on' } }, ctx);
+    }
+    return usage;
+}
+export const permissionsCommand = {
+    name: 'permissions', description: 'Inspect and explicitly switch shared autonomy policy profiles', usage,
+    async handler(args, ctx) {
+        try {
+            ctx.addMessage({ role: 'system', content: await run(args, ctx) });
         }
-        if (subCmd === 'set') {
-            const cap = normalize(args[1] || '');
-            const value = normalize(args[2] || '');
-            if (!cap || !ALL_CAPS.includes(cap)) {
-                ctx.addMessage({
-                    role: 'system',
-                    content: `Usage: /permissions set <${ALL_CAPS.join('|')}> <on|off>`
-                });
-                return;
-            }
-            if (value !== 'on' && value !== 'off') {
-                ctx.addMessage({
-                    role: 'system',
-                    content: 'Usage: /permissions set <capability> <on|off>'
-                });
-                return;
-            }
-            const next = { ...current, [cap]: value === 'on' };
-            ctx.config.set('toolPermissions', next);
-            await ctx.config.save();
-            ctx.reloadAgent();
-            ctx.addMessage({
-                role: 'system',
-                content: `✓ Permission updated: ${cap} ${value}`
-            });
-            return;
+        catch (error) {
+            ctx.addMessage({ role: 'system', content: `Permissions: ${error instanceof Error ? error.message : 'Profile could not be applied'}` });
         }
-        ctx.addMessage({
-            role: 'system',
-            content: 'Usage: /permissions <show|set|profiles|use> [capability|profile] [on|off]'
-        });
-    }
+    },
 };

package/dist/agent/commands/plan.js

@@ -438,23 +438,14 @@ export function commitPlan(planFile, planContent, tasks, ctx, autoApprove) {
         ctx.setMode?.(previousMode);
         throw error;
     }
-    // Publish tasks only after the normal agent exists. A failed rebuild must
-    // not leave a plan-mode session with implementation todos already armed.
-    if (ctx.setTodos && tasks.length > 0) {
-        ctx.setTodos(tasks.map((content, i) => ({
-            id: `plan_task_${i}`,
-            content,
-            status: 'pending',
-        })));
-    }
     ctx.addMessage({
         role: 'system',
-        content: `Plan approved. Beginning implementation.
+        content: `Plan mode off. Plan approved. Beginning implementation.
 
 Plan: ${planFile}
 Tasks extracted: ${tasks.length}
 
-${tasks.length > 0 ? 'Tasks have been added to the todo list.' : 'No tasks found in Implementation Steps section.'}`,
+${tasks.length > 0 ? 'Implementation steps are included in the plan below.' : 'No tasks found in Implementation Steps section.'}`,
     });
     // Add plan as context for the agent with explicit implementation instructions
     if (tasks.length > 0) {
@@ -462,12 +453,11 @@ ${tasks.length > 0 ? 'Tasks have been added to the todo list.' : 'No tasks found
             role: 'user',
             content: `Implement the following plan.
 
-IMPORTANT - after ALL implementation steps are done you MUST do these three things:
+IMPORTANT - after ALL implementation steps are done you MUST do these two things:
 1. Run the verification commands from the plan's Verification section to confirm everything works
-2. Use todo_write to mark ALL tasks as "completed"
-3. Print a brief final summary listing what was built and whether verification passed
+2. Print a brief final summary listing what was built and whether verification passed
 
-Do NOT skip steps 1-3. They are required.
+Do NOT skip steps 1-2. They are required.
 
 ${planContent}`,
         });

package/dist/agent/commands/profile.js

@@ -6,12 +6,13 @@ const USAGE = [
     '  /profile <name>              switch this session to an existing profile',
     '  /profile use <name>          same as above',
     '  /profile create <name>       create and switch to a custom profile',
+    '  /profile duplicate [name]    copy the active profile and switch to the copy',
 ].join('\n');
 const OLD_BENCHMARK_COMMANDS = new Set(['show', 'gates', 'command', 'run', 'optimize', 'sweep']);
 export const profileCommand = {
     name: 'profile',
-    description: 'List and switch configuration profiles',
-    usage: '[list|<name>|use <name>|create <name>]',
+    description: 'List, switch, create, and duplicate configuration profiles',
+    usage: '[list|<name>|use <name>|create <name>|duplicate [name]]',
     handler: async (args, ctx) => {
         const [action, ...rest] = args;
         if (!action || action === 'list' || action === 'configs' || action === 'help') {
@@ -31,6 +32,24 @@ export const profileCommand = {
             ctx.addMessage({ role: 'system', content: `Config profiles (* active):\n${lines.join('\n')}${!action ? `\n\n${USAGE}` : ''}` });
             return;
         }
+        if (action === 'duplicate' || action === 'copy' || action === 'clone') {
+            if (rest.length > 1) {
+                ctx.addMessage({ role: 'system', content: USAGE });
+                return;
+            }
+            const source = activeProfile();
+            const target = rest[0] ?? `${source}-copy`;
+            try {
+                if (!ctx.duplicateProfile)
+                    throw new Error('This renderer cannot switch config profiles in place.');
+                const name = await ctx.duplicateProfile(target, source);
+                ctx.addMessage({ role: 'system', content: `Duplicated config profile ${source} to ${name} and switched to it.` });
+            }
+            catch (error) {
+                ctx.addMessage({ role: 'system', content: `Profile duplicate failed: ${error.message}` });
+            }
+            return;
+        }
         if (OLD_BENCHMARK_COMMANDS.has(action)) {
             ctx.addMessage({ role: 'system', content: 'Use /emulation to inspect prompt modes. Profile benchmark gates remain available through npm run profiles:baseline.' });
             return;

package/dist/agent/commands/provider_selection.js

@@ -4,6 +4,7 @@ import { applyRuntimeModelSelection, getEffectiveModel } from './runtime_model.j
 import { canRouteThroughRouter, canonicalProvider } from './provider_choices.js';
 import { resolveModelAndProvider } from '../../panes/model_catalog.js';
 import { getDefaultModel } from '../../utils/models.js';
+import { resolveRouterModel, RouterCatalogAuthenticationError } from '../../utils/router_catalog.js';
 /** Apply a provider and optional model in one validated config transition. */
 export async function selectProviderModel(args, ctx) {
     const values = args.filter(Boolean);
@@ -27,11 +28,29 @@ export async function selectProviderModel(args, ctx) {
     const authMode = routed ? 'zrouter' : 'direct';
     const defaultModel = provider === 'inception' ? getDefaultModel(provider) : getDefaultModelForProvider(provider);
     const explicitModel = values[choice === 'zergrouter' ? 2 : 1];
-    const model = explicitModel || (provider === current ? getEffectiveModel(ctx)
+    let model = explicitModel || (provider === current ? getEffectiveModel(ctx)
         : provider === 'openai_compatible'
             ? (ctx.config.getOpenAICompatibleSettings?.().defaultModel || getDefaultModelForProvider(provider))
             : resolveModelAndProvider(defaultModel, provider).model);
     try {
+        if (routed && ctx.models.catalog) {
+            const catalog = await ctx.models.catalog(undefined, { refresh: !explicitModel }).catch(error => {
+                if (error instanceof RouterCatalogAuthenticationError)
+                    throw error;
+                return undefined;
+            });
+            if (catalog?.authRequired)
+                throw new Error('Router authentication rejected. Run /auth login and retry.');
+            if (catalog?.version === 1) {
+                const models = catalog.models.filter(row => row.owned_by === provider && row.capabilities?.chat);
+                if (!explicitModel)
+                    model = models.find(row => row.is_default)?.id ?? models[0]?.id ?? '';
+                const selected = resolveRouterModel(catalog, provider, model);
+                if (!selected?.capabilities?.chat)
+                    throw new Error('Model is not in the Router catalog. Run /model zergrouter to choose an available model.');
+                model = selected.id;
+            }
+        }
         const llm = ctx.config.resolveLLMBackendConfig({ provider, model,
             config: { ...ctx.config.get(), provider, model, authMode } });
         if (llm.authMode !== authMode) {

package/dist/agent/commands/rename.js

@@ -29,7 +29,7 @@ export const renameCommand = {
             return;
         }
         const sessionId = ctx.getSessionId();
-        const cwd = ctx.shell.getCwd();
+        const cwd = (ctx.getSessionCwd?.() ?? ctx.shell.getCwd());
         if (args.length === 0) {
             ctx.addMessage({
                 role: 'system',

package/dist/agent/commands/resources.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from './types.js';
+export declare const resourcesCommand: Command;

package/dist/agent/commands/resources.js

@@ -0,0 +1,67 @@
+import { guardedRemoteSession, requestRemoteResource } from '../runtime/remote_resources.js';
+export const resourcesCommand = {
+    name: 'resources',
+    description: 'Inspect ownership and reconcile uncertain guarded remote mutations',
+    agentRunnable: false,
+    usage: '/resources <show|claim|transfer|stop|reconcile|resolve> [resource] [generation-or-operation-id] [target-owner-or-observation-token] [ttl-seconds]',
+    handler: async (args, ctx) => {
+        const report = (content) => ctx.addMessage({ role: 'system', content });
+        if (ctx.commandOrigin === 'agent') {
+            report('Resource ownership changes require the user to type /resources. Chat and agent requests cannot grant ownership.');
+            return;
+        }
+        if (!ctx.getSessionId) {
+            report('Remote resource controls require a host session identity.');
+            return;
+        }
+        const session = guardedRemoteSession(ctx.getSessionId(), ctx.config.get().remoteResources);
+        if (!session) {
+            report('Configure remoteResources in the active profile to start a guarded remote session.');
+            return;
+        }
+        const operation = args[0] || 'show';
+        let leaseDispatched = false;
+        try {
+            if (operation === 'show') {
+                const resources = args[1] ? session.resources.filter(resource => resource.id === args[1]) : session.resources;
+                if (args[1] && !resources.length)
+                    throw new Error(`Unknown host-managed resource: ${args[1]}`);
+                const lines = [`Immutable owner ID: ${session.ownerId}`];
+                for (const resource of resources) {
+                    const status = await requestRemoteResource(session, resource.id, 'status');
+                    lines.push(`${resource.id}: ${JSON.stringify(status)}`);
+                }
+                report(lines.join('\n'));
+                return;
+            }
+            if (operation === 'reconcile' || operation === 'resolve') {
+                if (!args[1] || !args[2] || !/^[a-f0-9]{8}(?:-[a-f0-9]{4}){3}-[a-f0-9]{12}$/.test(args[2]))
+                    throw new Error('Reconciliation requires a resource and canonical operation UUID.');
+                if (operation === 'resolve' && (!args[3] || !/^[a-f0-9]{64}$/.test(args[3])))
+                    throw new Error('Inspect reconcile first, then supply its exact observation token to accept the current state.');
+                const result = await requestRemoteResource(session, args[1], operation, { receipt_id: args[2], observation_token: args[3] });
+                report(`${args[1]} ${operation}${operation === 'resolve' ? ' confirmed' : ''}: ${JSON.stringify(result)}${operation === 'reconcile'
+                    ? '\nAccept current state only after reviewing the receipt, current target and retained staging data: /resources resolve ' + args[1] + ' ' + args[2] + ' <observation-token>. This releases admission; it does not replay the operation or prove an uncertain earlier effect.' : ''}`);
+                return;
+            }
+            if (!['claim', 'transfer', 'stop'].includes(operation) || !args[1] || !args[2]) {
+                throw new Error('Usage: /resources show [resource]; /resources claim <resource> <generation> [ttl-seconds]; /resources transfer <resource> <generation> <target-owner-id> [ttl-seconds]; /resources stop <resource> <generation>. Inspect show before confirming.');
+            }
+            const generation = Number(args[2]);
+            if (!Number.isSafeInteger(generation) || generation < 0)
+                throw new Error('Expected generation must be a non-negative integer from /resources show.');
+            const ttl = Number(args[operation === 'transfer' ? 4 : 3] ?? 900);
+            leaseDispatched = true;
+            const result = await requestRemoteResource(session, args[1], operation, {
+                expected_generation: generation,
+                ...(operation === 'transfer' ? { target_owner_id: args[3] } : {}),
+                ttl_seconds: ttl,
+            });
+            report(`${args[1]} ${operation} confirmed: ${JSON.stringify(result)}`);
+        }
+        catch (error) {
+            report(`Resource action failed: ${error.message}${leaseDispatched
+                ? `\nInspect the current owner and generation with /resources show ${args[1]} before retrying; a failed response alone does not establish the lease outcome.` : ''}`);
+        }
+    },
+};

package/dist/agent/commands/rewind.d.ts

@@ -0,0 +1,3 @@
+import type { Command } from './types.js';
+/** History replacement is an explicit user action, separate from stopping. */
+export declare const rewindCommand: Command;

package/dist/agent/commands/rewind.js

@@ -0,0 +1,16 @@
+/** History replacement is an explicit user action, separate from stopping. */
+export const rewindCommand = {
+    name: 'rewind',
+    description: 'Choose an earlier prompt to restore and remove its following context',
+    usage: '/rewind',
+    handler: (_, ctx) => {
+        if (!ctx.rewindPanel) {
+            ctx.addMessage({
+                role: 'system',
+                content: 'The rewind picker requires the Ratatui renderer. Start a Ratatui ZTC terminal and use /rewind to choose an earlier prompt.',
+            });
+            return;
+        }
+        ctx.rewindPanel.open();
+    },
+};

package/dist/agent/commands/runbooks.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from './types.js';
+export declare const runbooksCommand: Command;

package/dist/agent/commands/runbooks.js

@@ -0,0 +1,73 @@
+import { findRunbook, installRunbook, listRunbooks } from '../../runbooks/library.js';
+import { prepareRunbookRun } from '../../runbooks/package.js';
+import { ensureWorkflowRegistry } from '../../workflows/registry_lazy.js';
+function describe(book) {
+    const value = book.package;
+    return [value.name, value.description, `Source: ${book.source}`, `Content SHA256: ${book.digest}`,
+        ...(book.installedFrom ? [`Recorded install source (advisory): ${book.installedFrom.source}; source content SHA256: ${book.installedFrom.digest}`] : []),
+        `Package schema: ${value.schemaVersion}; requires Node ${value.minimumNodeMajor}+`,
+        `Required tools: ${value.requiredTools.map(names => names.join(' or ')).join('; ') || 'none'}`,
+        'Inputs:', ...value.inputs.map(input => `  ${input.name}${input.required ? ' (required)' : ' (optional)'}: ${input.description}`),
+        'Expected evidence (not observed verification):', ...value.expectedEvidence.map(text => `  ${text}`),
+        `Workflow entrypoint: ${value.entrypoint}; scripts: ${Object.keys(value.scripts).join(', ')}`,
+        '', value.instructions, '', 'Installation does not authorize execution. Invocation retains current workflow and tool permissions.'].join('\n');
+}
+export const runbooksCommand = {
+    name: 'runbooks', description: 'Browse, inspect, install, and invoke runbooks',
+    usage: '/runbooks [list|show|install|run]', agentRunnable: false, category: 'workflow',
+    handler: async (args, ctx) => {
+        if (ctx.commandOrigin === 'agent') {
+            ctx.addMessage({ role: 'system', content: 'Runbook installation and invocation require an explicit user command.' });
+            return;
+        }
+        const cwd = ctx.shell.getCwd();
+        try {
+            const action = args[0] ?? 'list';
+            if (action === 'list') {
+                const catalog = await listRunbooks(cwd);
+                ctx.addMessage({ role: 'system', content: ['Available runbooks:',
+                        ...catalog.runbooks.map(book => `  ${book.package.id}: ${book.package.description} (${book.source})`),
+                        ...catalog.errors.map(error => `Library error: ${error}`),
+                        'Use /runbooks show <id> to inspect prerequisites, inputs, instructions and expected evidence.'].join('\n') });
+                return;
+            }
+            const source = args[1];
+            if (!source || !['show', 'install', 'run'].includes(action))
+                throw new Error('Usage: /runbooks [list|show <id-or-path>|install <id-or-path>|run <id-or-path> [--args <JSON>]]');
+            if (action === 'install') {
+                const installed = await installRunbook(source, cwd);
+                ctx.addMessage({ role: 'system', content: `Runbook installed: ${installed.path}\nSource: ${installed.book.source}\nContent SHA256: ${installed.book.digest}\nNo scripts were executed. Inspect with /runbooks show ${installed.book.package.id}; invoke explicitly with /runbooks run ${installed.book.package.id}. Current permissions still apply.` });
+                return;
+            }
+            const book = await findRunbook(source, cwd);
+            if (action === 'show') {
+                ctx.addMessage({ role: 'system', content: describe(book) });
+                return;
+            }
+            if (args.length > 2 && (args[2] !== '--args' || args.length < 4))
+                throw new Error('Use /runbooks run <id-or-path> [--args <JSON object>].');
+            let inputs = {};
+            if (args.length >= 4) {
+                // ZTC splits slash input on whitespace, as does the existing workflow command.
+                try {
+                    inputs = JSON.parse(args.slice(3).join(' '));
+                }
+                catch {
+                    throw new Error('Runbook --args must be a valid JSON object.');
+                }
+            }
+            const execution = ctx.getExecutionContext?.();
+            if (!execution)
+                throw new Error('Current tool capabilities are unavailable. Open a compatible configured ZTC session before invoking a runbook.');
+            const prepared = prepareRunbookRun(book, inputs, execution.tools);
+            const registry = await ensureWorkflowRegistry();
+            if (!registry)
+                throw new Error('Workflow registry is not initialized. Configure an API provider before invoking a runbook.');
+            const runId = registry.startInline(prepared);
+            ctx.addMessage({ role: 'system', content: `Runbook ${book.package.id} started: ${runId}\nSource: ${book.source}\nContent SHA256: ${book.digest}\nExpected evidence is a plan, not verified output. Inspect actual results with /workflows show ${runId}.` });
+        }
+        catch (error) {
+            ctx.addMessage({ role: 'system', content: error instanceof Error ? error.message : String(error) });
+        }
+    },
+};

package/dist/agent/commands/runbooks_lazy.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from './types.js';
+export declare const runbooksCommand: Command;

package/dist/agent/commands/runbooks_lazy.js

@@ -0,0 +1,8 @@
+export const runbooksCommand = {
+    name: 'runbooks', description: 'Browse, inspect, install, and invoke runbooks',
+    usage: '/runbooks [list|show|install|run]', agentRunnable: false, category: 'workflow',
+    handler: async (args, ctx) => {
+        const { runbooksCommand: implementation } = await import('./runbooks.js');
+        return implementation.handler(args, ctx);
+    },
+};

package/dist/agent/commands/sessions.d.ts

@@ -1,2 +1,2 @@
-import { Command } from './types.js';
+import type { Command } from './types.js';
 export declare const sessionsCommand: Command;

package/dist/agent/commands/sessions.js

@@ -1,11 +1,35 @@
 import { listSessions, deleteSession } from '../../session.js';
+import { inspectWorkspaceSessions, formatWorkspaceSnapshot } from '../../workspace_collision.js';
 export const sessionsCommand = {
     name: 'sessions',
-    description: 'List or manage saved sessions for current directory',
-    usage: '/sessions [list|delete <id>]',
+    description: 'Inspect active local workspace peers or manage saved sessions',
+    usage: '/sessions [active|continue|isolate|list|delete <id>]',
     handler: async (args, ctx) => {
-        const cwd = ctx.shell.getCwd();
+        const cwd = (ctx.getSessionCwd?.() ?? ctx.shell.getCwd());
         const subcommand = args[0] || 'list';
+        if (subcommand === 'active') {
+            const snapshot = ctx.workspace
+                ? await ctx.workspace.getSnapshot()
+                : await inspectWorkspaceSessions(cwd, ctx.getSessionId?.());
+            ctx.addMessage({ role: 'system', content: formatWorkspaceSnapshot(snapshot) });
+            return;
+        }
+        if (subcommand === 'continue' || subcommand === 'isolate') {
+            if (ctx.commandOrigin === 'agent') {
+                ctx.addMessage({ role: 'system', content: 'Local workspace continuation and isolation require the user to choose. Remote authority remains unchanged.' });
+                return;
+            }
+            if (args.length !== 1) {
+                ctx.addMessage({ role: 'system', content: 'Usage: /sessions continue | /sessions isolate' });
+                return;
+            }
+            if (!ctx.workspace) {
+                ctx.addMessage({ role: 'system', content: 'This surface cannot continue or isolate a local session. Use an interactive ZTC session. No workspace or remote authority was changed.' });
+                return;
+            }
+            await ctx.workspace[subcommand]();
+            return;
+        }
         if (subcommand === 'list') {
             const sessions = await listSessions(cwd);
             if (sessions.length === 0) {
@@ -16,16 +40,20 @@ export const sessionsCommand = {
                 return;
             }
             const lines = ['Saved sessions:\n'];
+            sessions.sort((a, b) => Number(Boolean(b.labels?.pinned)) - Number(Boolean(a.labels?.pinned)) || (a.labels?.group ?? '').localeCompare(b.labels?.group ?? ''));
             for (const session of sessions) {
                 const date = new Date(session.updatedAt).toLocaleString();
+                const labelTag = [session.labels?.pinned ? 'pinned' : undefined, session.labels?.group, session.labels?.project, session.labels?.task].filter(Boolean).join(' · ');
                 const nameTag = session.name ? ` [${session.name}]` : '';
                 lines.push(`  ${session.id}${nameTag}  ${date}  (${session.messageCount} messages)`);
+                if (labelTag)
+                    lines.push(`    ${labelTag}`);
                 lines.push(`    ${session.title.slice(0, 60)}${session.title.length > 60 ? '...' : ''}\n`);
             }
             lines.push('\nResume with: /resume (interactive picker)');
             lines.push('Or directly: ztc resume <id-or-name>');
             lines.push('Or: ztc resume (opens the picker), ztc -c (most recent)');
-            lines.push('Set a name with: /rename <name>');
+            lines.push('Set a name with: /rename <name>. Pin or group with: /label pin, /label group <name>');
             lines.push('If the session was saved in zmux, resume also restores its pane layout.');
             lines.push('Legacy alias: ztc --resume [id-or-name]');
             ctx.addMessage({
@@ -59,7 +87,7 @@ export const sessionsCommand = {
         else {
             ctx.addMessage({
                 role: 'system',
-                content: 'Usage: /sessions [list|delete <id>]',
+                content: 'Usage: /sessions [active|continue|isolate|list|delete <id>]',
             });
         }
     },