zerg-status 1.1.0 → 2.0.0

package/dist/__tests__/commands.test.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Integration tests for zerg-status CLI commands
+ */
+export {};

package/dist/__tests__/commands.test.js

@@ -0,0 +1,258 @@
+/**
+ * Integration tests for zerg-status CLI commands
+ */
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { fileURLToPath } from 'url';
+import { test, describe, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const STATE_DIR = path.join(os.homedir(), '.zerg-status');
+const BIN_PATH = path.join(__dirname, '../../dist/index.js');
+// Helper to run zerg-status commands
+function runCommand(args) {
+    try {
+        const stdout = execSync(`node ${BIN_PATH} ${args}`, {
+            encoding: 'utf-8',
+            timeout: 5000,
+        });
+        return { stdout, stderr: '', exitCode: 0 };
+    }
+    catch (err) {
+        const error = err;
+        return {
+            stdout: error.stdout || '',
+            stderr: error.stderr || '',
+            exitCode: error.status || 1,
+        };
+    }
+}
+// Helper to parse ZERG_SESSION output
+function parseSessionOutput(output) {
+    const match = output.match(/ZERG_SESSION:([a-f0-9]+)(?::(.+))?/);
+    if (!match)
+        return null;
+    return { sessionId: match[1], name: match[2] };
+}
+// Helper to parse ZERG_STATUS output
+function parseStatusOutput(output) {
+    const match = output.match(/ZERG_STATUS:(\{[\s\S]*\})/);
+    if (!match)
+        return null;
+    try {
+        return JSON.parse(match[1]);
+    }
+    catch {
+        return null;
+    }
+}
+// Clean up test sessions
+function cleanupSession(sessionId) {
+    const statePath = path.join(STATE_DIR, `${sessionId}.json`);
+    if (fs.existsSync(statePath)) {
+        fs.unlinkSync(statePath);
+    }
+}
+// Track test session for cleanup
+let testSessionId = '';
+describe('zerg-status CLI', () => {
+    afterEach(() => {
+        // Clean up test session if created
+        if (testSessionId) {
+            cleanupSession(testSessionId);
+            testSessionId = '';
+        }
+    });
+    describe('init command', () => {
+        test('should create a new session with name', () => {
+            const result = runCommand('init "Fix auth bug"');
+            assert.strictEqual(result.exitCode, 0);
+            const parsed = parseSessionOutput(result.stdout);
+            assert.ok(parsed, 'Should parse session output');
+            assert.match(parsed.sessionId, /^[a-f0-9]{8}$/);
+            assert.strictEqual(parsed.name, 'Fix auth bug');
+            testSessionId = parsed.sessionId;
+        });
+        test('should create a new session without name', () => {
+            const result = runCommand('init');
+            assert.strictEqual(result.exitCode, 0);
+            const parsed = parseSessionOutput(result.stdout);
+            assert.ok(parsed, 'Should parse session output');
+            assert.match(parsed.sessionId, /^[a-f0-9]{8}$/);
+            testSessionId = parsed.sessionId;
+        });
+        test('should reject names that are too long', () => {
+            const result = runCommand('init "This is a very long session name that has more than six words"');
+            assert.strictEqual(result.exitCode, 1);
+            assert.ok(result.stderr.includes('too long') || result.stderr.includes('Max'), 'Should reject names that are too long');
+        });
+    });
+    describe('ask command', () => {
+        beforeEach(() => {
+            const initResult = runCommand('init "Test session"');
+            const parsed = parseSessionOutput(initResult.stdout);
+            testSessionId = parsed.sessionId;
+        });
+        test('should set state to ask with question', () => {
+            const result = runCommand(`-s ${testSessionId} ask "Which database to use?"`);
+            assert.strictEqual(result.exitCode, 0);
+            const status = parseStatusOutput(result.stdout);
+            assert.ok(status, 'Should parse status output');
+            assert.strictEqual(status.state, 'ask');
+            assert.strictEqual(status.ask, 'Which database to use?');
+        });
+        test('should set ask with clickable options', () => {
+            const result = runCommand(`-s ${testSessionId} ask "Which database?" -- "Redis: Fast caching" "PostgreSQL: Relational DB"`);
+            assert.strictEqual(result.exitCode, 0);
+            const status = parseStatusOutput(result.stdout);
+            assert.ok(status, 'Should parse status output');
+            assert.strictEqual(status.state, 'ask');
+            assert.strictEqual(status.ask, 'Which database?');
+            assert.deepStrictEqual(status.askOptions, [
+                { name: 'Redis', desc: 'Fast caching' },
+                { name: 'PostgreSQL', desc: 'Relational DB' },
+            ]);
+        });
+        test('should parse options without descriptions', () => {
+            const result = runCommand(`-s ${testSessionId} ask "Yes or no?" -- "Yes" "No"`);
+            assert.strictEqual(result.exitCode, 0);
+            const status = parseStatusOutput(result.stdout);
+            assert.deepStrictEqual(status?.askOptions, [
+                { name: 'Yes' },
+                { name: 'No' },
+            ]);
+        });
+        test('should reject too few options', () => {
+            const result = runCommand(`-s ${testSessionId} ask "Question?" -- "OnlyOne"`);
+            assert.strictEqual(result.exitCode, 1);
+            assert.ok(result.stderr.includes('Too few options'), 'Should reject too few options');
+        });
+        test('should reject too many options', () => {
+            const result = runCommand(`-s ${testSessionId} ask "Question?" -- "A" "B" "C" "D" "E" "F"`);
+            assert.strictEqual(result.exitCode, 1);
+            assert.ok(result.stderr.includes('Too many options'), 'Should reject too many options');
+        });
+        test('should require a question', () => {
+            const result = runCommand(`-s ${testSessionId} ask`);
+            assert.strictEqual(result.exitCode, 1);
+            assert.ok(result.stderr.includes('Question text required'), 'Should require question text');
+        });
+    });
+    describe('done command', () => {
+        beforeEach(() => {
+            const initResult = runCommand('init "Test session"');
+            const parsed = parseSessionOutput(initResult.stdout);
+            testSessionId = parsed.sessionId;
+        });
+        test('should set state to done with summary', () => {
+            const result = runCommand(`-s ${testSessionId} done "Fixed auth bug. All tests pass."`);
+            assert.strictEqual(result.exitCode, 0);
+            const status = parseStatusOutput(result.stdout);
+            assert.ok(status, 'Should parse status output');
+            assert.strictEqual(status.state, 'done');
+            assert.strictEqual(status.done, 'Fixed auth bug. All tests pass.');
+        });
+        test('should clear ask fields when done', () => {
+            // First set to ask
+            runCommand(`-s ${testSessionId} ask "Question?" -- "A" "B"`);
+            // Then set to done
+            const result = runCommand(`-s ${testSessionId} done "Completed the task."`);
+            const status = parseStatusOutput(result.stdout);
+            assert.strictEqual(status?.state, 'done');
+            assert.strictEqual(status?.ask, undefined);
+            assert.strictEqual(status?.askOptions, undefined);
+        });
+        test('should require a summary', () => {
+            const result = runCommand(`-s ${testSessionId} done`);
+            assert.strictEqual(result.exitCode, 1);
+            assert.ok(result.stderr.includes('Result summary required'), 'Should require summary');
+        });
+    });
+    describe('now command', () => {
+        beforeEach(() => {
+            const initResult = runCommand('init "Test session"');
+            const parsed = parseSessionOutput(initResult.stdout);
+            testSessionId = parsed.sessionId;
+        });
+        test('should set current activity', () => {
+            const result = runCommand(`-s ${testSessionId} now "Analyzing auth flow"`);
+            assert.strictEqual(result.exitCode, 0);
+            const status = parseStatusOutput(result.stdout);
+            assert.strictEqual(status?.now, 'Analyzing auth flow');
+        });
+        test('should reject text that is too long', () => {
+            const longText = 'A'.repeat(60);
+            const result = runCommand(`-s ${testSessionId} now "${longText}"`);
+            assert.strictEqual(result.exitCode, 1);
+            assert.ok(result.stderr.includes('too long'), 'Should reject long text');
+        });
+    });
+    describe('tasks commands', () => {
+        beforeEach(() => {
+            const initResult = runCommand('init "Test session"');
+            const parsed = parseSessionOutput(initResult.stdout);
+            testSessionId = parsed.sessionId;
+        });
+        test('should set task list', () => {
+            const result = runCommand(`-s ${testSessionId} tasks set "Analyze" "Implement" "Test"`);
+            assert.strictEqual(result.exitCode, 0);
+            const status = parseStatusOutput(result.stdout);
+            assert.deepStrictEqual(status?.tasks, [
+                { task: 'Analyze', status: 'todo' },
+                { task: 'Implement', status: 'todo' },
+                { task: 'Test', status: 'todo' },
+            ]);
+        });
+        test('should mark task as doing', () => {
+            runCommand(`-s ${testSessionId} tasks set "Analyze" "Implement" "Test"`);
+            const result = runCommand(`-s ${testSessionId} task doing "Analyze"`);
+            assert.strictEqual(result.exitCode, 0);
+            const status = parseStatusOutput(result.stdout);
+            const tasks = status?.tasks;
+            const analyzeTask = tasks.find(t => t.task === 'Analyze');
+            assert.strictEqual(analyzeTask?.status, 'doing');
+        });
+        test('should mark task as done', () => {
+            runCommand(`-s ${testSessionId} tasks set "Analyze" "Implement" "Test"`);
+            const result = runCommand(`-s ${testSessionId} task done "Analyze"`);
+            assert.strictEqual(result.exitCode, 0);
+            const status = parseStatusOutput(result.stdout);
+            const tasks = status?.tasks;
+            const analyzeTask = tasks.find(t => t.task === 'Analyze');
+            assert.strictEqual(analyzeTask?.status, 'done');
+        });
+    });
+    describe('full workflow', () => {
+        test('should handle a complete session workflow', () => {
+            // 1. Initialize session
+            const initResult = runCommand('init "Fix auth bug"');
+            const parsed = parseSessionOutput(initResult.stdout);
+            testSessionId = parsed.sessionId;
+            // 2. Set up tasks
+            runCommand(`-s ${testSessionId} tasks set "Investigate" "Fix" "Test"`);
+            runCommand(`-s ${testSessionId} task doing "Investigate"`);
+            runCommand(`-s ${testSessionId} now "Analyzing auth module"`);
+            // 3. Ask a question with options
+            const askResult = runCommand(`-s ${testSessionId} ask "Use JWT or sessions?" -- "JWT: Stateless" "Sessions: Simpler"`);
+            let status = parseStatusOutput(askResult.stdout);
+            assert.strictEqual(status?.state, 'ask');
+            assert.strictEqual(status?.ask, 'Use JWT or sessions?');
+            const askOptions = status?.askOptions;
+            assert.strictEqual(askOptions.length, 2);
+            // 4. Resume work after getting answer
+            runCommand(`-s ${testSessionId} task done "Investigate"`);
+            runCommand(`-s ${testSessionId} task doing "Fix"`);
+            runCommand(`-s ${testSessionId} now "Implementing JWT auth"`);
+            // 5. Finish
+            const doneResult = runCommand(`-s ${testSessionId} done "Fixed auth bug. JWT tokens working, 12 tests added."`);
+            status = parseStatusOutput(doneResult.stdout);
+            assert.strictEqual(status?.state, 'done');
+            assert.strictEqual(status?.done, 'Fixed auth bug. JWT tokens working, 12 tests added.');
+            // ask fields should be cleared
+            assert.strictEqual(status?.ask, undefined);
+            assert.strictEqual(status?.askOptions, undefined);
+        });
+    });
+});

package/dist/commands/ask.d.ts

@@ -0,0 +1,8 @@
+/**
+ * ask command - Set state to blocked with a question and optional clickable options.
+ *
+ * Usage:
+ *   zerg-status -s <id> ask "Which database?"
+ *   zerg-status -s <id> ask "Which database?" -- "Redis: Fast" "Postgres: Simple"
+ */
+export declare function askCommand(sessionId: string, question: string, options?: string[]): void;

package/dist/commands/ask.js

@@ -0,0 +1,13 @@
+import { setAsk } from '../state.js';
+import { formatStatusOutput } from '../output.js';
+/**
+ * ask command - Set state to blocked with a question and optional clickable options.
+ *
+ * Usage:
+ *   zerg-status -s <id> ask "Which database?"
+ *   zerg-status -s <id> ask "Which database?" -- "Redis: Fast" "Postgres: Simple"
+ */
+export function askCommand(sessionId, question, options) {
+    const state = setAsk(sessionId, question, options);
+    console.log(formatStatusOutput(state));
+}

package/dist/commands/done.d.ts

@@ -0,0 +1,7 @@
+/**
+ * done command - Set state to finished with a result summary.
+ *
+ * Usage:
+ *   zerg-status -s <id> done "Fixed auth bug. JWT refresh working, 12 tests pass."
+ */
+export declare function doneCommand(sessionId: string, summary: string): void;

package/dist/commands/done.js

@@ -0,0 +1,12 @@
+import { setDone } from '../state.js';
+import { formatStatusOutput } from '../output.js';
+/**
+ * done command - Set state to finished with a result summary.
+ *
+ * Usage:
+ *   zerg-status -s <id> done "Fixed auth bug. JWT refresh working, 12 tests pass."
+ */
+export function doneCommand(sessionId, summary) {
+    const state = setDone(sessionId, summary);
+    console.log(formatStatusOutput(state));
+}

package/dist/commands/notify.d.ts

@@ -0,0 +1 @@
+export declare function notifyCommand(sessionId: string, text: string): void;

package/dist/commands/notify.js

@@ -0,0 +1,8 @@
+import { setNotify } from '../state.js';
+import { validateNotify } from '../validate.js';
+import { formatStatusOutput } from '../output.js';
+export function notifyCommand(sessionId, text) {
+    const validText = validateNotify(text);
+    const state = setNotify(sessionId, validText);
+    console.log(formatStatusOutput(state));
+}

package/dist/index.d.ts

@@ -2,17 +2,14 @@
 /**
  * zerg-status - Progress reporting CLI for Zerg dashboard
  *
- * Usage:
+ * COMMANDS:
  *   npx zerg-status init "Session Name"            # Initialize session with name
- *   npx zerg-status init                           # Initialize session, outputs ZERG_SESSION:<id>
- *   npx zerg-status -s <id> state work             # Set state to work/ask/done
- *   npx zerg-status -s <id> state ask "Question?"  # Set state to ask with a question
- *   npx zerg-status -s <id> now "Headline"         # Set current activity headline
- *   npx zerg-status -s <id> summary "Details"      # Set detailed summary
- *   npx zerg-status -s <id> task add "Task"        # Add a task
- *   npx zerg-status -s <id> task doing "Task"      # Mark task as in progress
- *   npx zerg-status -s <id> task done "Task"       # Mark task as complete
- *   npx zerg-status -s <id> task clear             # Clear all tasks
- *   npx zerg-status -s <id> tasks set "A" "B" "C"  # Replace all tasks
+ *   npx zerg-status -s <id> now "Activity"         # Set current activity (while working)
+ *   npx zerg-status -s <id> ask "Question?"        # Set blocked state with question
+ *   npx zerg-status -s <id> ask "Q?" -- "A: desc" "B: desc"  # With clickable options
+ *   npx zerg-status -s <id> done "Result summary"  # Set done state with summary
+ *   npx zerg-status -s <id> tasks set "A" "B" "C"  # Set task list
+ *   npx zerg-status -s <id> task doing "A"         # Mark task in progress
+ *   npx zerg-status -s <id> task done "A"          # Mark task complete
  */
 export {};

package/dist/index.js

@@ -2,23 +2,20 @@
 /**
  * zerg-status - Progress reporting CLI for Zerg dashboard
  *
- * Usage:
+ * COMMANDS:
  *   npx zerg-status init "Session Name"            # Initialize session with name
- *   npx zerg-status init                           # Initialize session, outputs ZERG_SESSION:<id>
- *   npx zerg-status -s <id> state work             # Set state to work/ask/done
- *   npx zerg-status -s <id> state ask "Question?"  # Set state to ask with a question
- *   npx zerg-status -s <id> now "Headline"         # Set current activity headline
- *   npx zerg-status -s <id> summary "Details"      # Set detailed summary
- *   npx zerg-status -s <id> task add "Task"        # Add a task
- *   npx zerg-status -s <id> task doing "Task"      # Mark task as in progress
- *   npx zerg-status -s <id> task done "Task"       # Mark task as complete
- *   npx zerg-status -s <id> task clear             # Clear all tasks
- *   npx zerg-status -s <id> tasks set "A" "B" "C"  # Replace all tasks
+ *   npx zerg-status -s <id> now "Activity"         # Set current activity (while working)
+ *   npx zerg-status -s <id> ask "Question?"        # Set blocked state with question
+ *   npx zerg-status -s <id> ask "Q?" -- "A: desc" "B: desc"  # With clickable options
+ *   npx zerg-status -s <id> done "Result summary"  # Set done state with summary
+ *   npx zerg-status -s <id> tasks set "A" "B" "C"  # Set task list
+ *   npx zerg-status -s <id> task doing "A"         # Mark task in progress
+ *   npx zerg-status -s <id> task done "A"          # Mark task complete
  */
 import { init } from './commands/init.js';
-import { stateCommand } from './commands/state.js';
 import { nowCommand } from './commands/now.js';
-import { summaryCommand } from './commands/summary.js';
+import { askCommand } from './commands/ask.js';
+import { doneCommand } from './commands/done.js';
 import { taskCommand } from './commands/task.js';
 import { tasksCommand } from './commands/tasks.js';
 import { validateSessionId, ValidationError } from './validate.js';
@@ -27,9 +24,23 @@ function parseArgs(argv) {
     let sessionId;
     let command = 'help';
     const commandArgs = [];
+    const optionsAfterSeparator = [];
+    let foundSeparator = false;
     let i = 0;
     while (i < args.length) {
         const arg = args[i];
+        // Handle -- separator for options
+        if (arg === '--') {
+            foundSeparator = true;
+            i++;
+            continue;
+        }
+        // Everything after -- goes to optionsAfterSeparator
+        if (foundSeparator) {
+            optionsAfterSeparator.push(arg);
+            i++;
+            continue;
+        }
         if (arg === '-s' || arg === '--session') {
             sessionId = args[i + 1];
             i += 2;
@@ -43,82 +54,86 @@ function parseArgs(argv) {
         commandArgs.push(arg);
         i++;
     }
-    return { sessionId, command, args: commandArgs };
+    return { sessionId, command, args: commandArgs, optionsAfterSeparator };
 }
 function printHelp() {
     console.log(`
 zerg-status - Progress reporting CLI for Zerg dashboard
 
 COMMANDS:
-  init "Session Name"            Initialize new session with name (outputs ZERG_SESSION:<id>:<name>)
-  init                           Initialize new session (outputs ZERG_SESSION:<id>)
-
-  -s <id> state <work|ask|done>  Set session state
-  -s <id> state ask "Question?"  Set state to ask with a question
-  -s <id> state done             Set state to done
+  init "Session Name"              Initialize session (outputs ZERG_SESSION:<id>:<name>)
 
-  -s <id> now "Headline"         Set current activity (max 50 chars)
-  -s <id> summary "Details"      Set detailed summary (max 500 chars)
+  -s <id> now "Activity"           Set current activity (max 50 chars, while working)
+  -s <id> ask "Question?"          Set blocked state with question
+  -s <id> ask "Q?" -- "A" "B"      Set blocked with clickable options (2-5 options)
+  -s <id> done "Result summary"    Set done state with result summary
 
-  -s <id> task add "Task"        Add a task (status: todo)
-  -s <id> task doing "Task"      Mark task as in progress
-  -s <id> task done "Task"       Mark task as complete
-  -s <id> task todo "Task"       Mark task as pending
-  -s <id> task clear             Clear all tasks
+  -s <id> tasks set "A" "B" "C"    Set task list (shows progress bar)
+  -s <id> task doing "Task"        Mark task as in progress
+  -s <id> task done "Task"         Mark task as complete
 
-  -s <id> tasks set "A" "B" "C"  Replace all tasks (max 20 tasks)
+OPTIONS FORMAT:
+  Options use "Name: Description" format. Description is optional.
+  Example: "Redis: Faster, needs separate server"
 
 EXAMPLES:
+  # Initialize session
   npx zerg-status init "Fix auth bug"
-  # ZERG_SESSION:f7a3b2c1:Fix auth bug
+  # Output: ZERG_SESSION:f7a3b2c1:Fix auth bug
+
+  # Set up tasks and start working
+  npx zerg-status -s f7a3b2c1 tasks set "Investigate" "Fix" "Test"
+  npx zerg-status -s f7a3b2c1 task doing "Investigate"
+  npx zerg-status -s f7a3b2c1 now "Analyzing auth module"
+
+  # When blocked with options
+  npx zerg-status -s f7a3b2c1 ask "Which database?" -- \\
+    "Redis: Faster, requires separate server" \\
+    "PostgreSQL: Simpler, uses existing DB"
 
-  npx zerg-status -s f7a3b2c1 state work
-  npx zerg-status -s f7a3b2c1 now "Writing unit tests"
-  npx zerg-status -s f7a3b2c1 tasks set "Task 1" "Task 2" "Task 3"
-  npx zerg-status -s f7a3b2c1 task doing "Task 1"
-  npx zerg-status -s f7a3b2c1 task done "Task 1"
-  npx zerg-status -s f7a3b2c1 state done
+  # When finished
+  npx zerg-status -s f7a3b2c1 done "Fixed auth bug. JWT refresh working, 8 tests added."
 
 OUTPUT:
-  init outputs:    ZERG_SESSION:<session_id>[:<name>]
-  all others:      ZERG_STATUS:<full_json_state>
+  init:    ZERG_SESSION:<id>[:<name>]
+  others:  ZERG_STATUS:<json_state>
 `);
 }
 function main() {
     try {
-        const { sessionId, command, args } = parseArgs(process.argv);
+        const { sessionId, command, args, optionsAfterSeparator } = parseArgs(process.argv);
         switch (command) {
             case 'init': {
                 const name = args.join(' ') || undefined;
                 init(name);
                 break;
             }
-            case 'state': {
+            case 'ask': {
                 const validSessionId = validateSessionId(sessionId);
-                const [stateValue, ...rest] = args;
-                if (!stateValue) {
-                    throw new ValidationError('State value required. Use: work, ask, or done');
+                const question = args.join(' ');
+                if (!question) {
+                    throw new ValidationError('Question text required. Example: ask "Which database?"');
                 }
-                const question = stateValue === 'ask' ? rest.join(' ') : undefined;
-                stateCommand(validSessionId, stateValue, question);
+                const options = optionsAfterSeparator.length > 0 ? optionsAfterSeparator : undefined;
+                askCommand(validSessionId, question, options);
                 break;
             }
-            case 'now': {
+            case 'done': {
                 const validSessionId = validateSessionId(sessionId);
-                const text = args.join(' ');
-                if (!text) {
-                    throw new ValidationError('Now text required');
+                const summary = args.join(' ');
+                if (!summary) {
+                    throw new ValidationError('Result summary required. Example: done "Fixed bug, 8 tests pass."');
                 }
-                nowCommand(validSessionId, text);
+                doneCommand(validSessionId, summary);
                 break;
             }
-            case 'summary': {
+            case 'now': {
                 const validSessionId = validateSessionId(sessionId);
                 const text = args.join(' ');
                 if (!text) {
-                    throw new ValidationError('Summary text required');
+                    throw new ValidationError('Now text required');
                 }
-                summaryCommand(validSessionId, text);
+                nowCommand(validSessionId, text);
                 break;
             }
             case 'task': {

package/dist/state.d.ts

@@ -10,7 +10,18 @@ export declare function updateState(sessionId: string, updates: Partial<ZergStat
 export declare function setState(sessionId: string, newState: State, question?: string): ZergState;
 export declare function setNow(sessionId: string, now: string): ZergState;
 export declare function setSummary(sessionId: string, summary: string): ZergState;
+export declare function setNotify(sessionId: string, notify: string): ZergState;
 export declare function addTask(sessionId: string, taskDescription: string, status?: TaskStatus): ZergState;
 export declare function updateTaskStatus(sessionId: string, taskDescription: string, status: TaskStatus): ZergState;
 export declare function clearTasks(sessionId: string): ZergState;
 export declare function setTasks(sessionId: string, taskDescriptions: string[]): ZergState;
+/**
+ * Set ask state with question and optional clickable options.
+ * This is the new unified command that sets state=ask AND stores the question.
+ */
+export declare function setAsk(sessionId: string, question: string, optionStrings?: string[]): ZergState;
+/**
+ * Set done state with result summary.
+ * This is the new unified command that sets state=done AND stores the summary.
+ */
+export declare function setDone(sessionId: string, summary: string): ZergState;

package/dist/state.js

@@ -3,7 +3,7 @@ import path from 'path';
 import os from 'os';
 import crypto from 'crypto';
 import { DEFAULT_STATE } from './types.js';
-import { validateTaskCount, validateTask } from './validate.js';
+import { validateTaskCount, validateTask, validateAsk, validateDone, validateAskOptions } from './validate.js';
 const STATE_DIR = path.join(os.homedir(), '.zerg-status');
 function ensureStateDir() {
     if (!fs.existsSync(STATE_DIR)) {
@@ -74,6 +74,9 @@ export function setNow(sessionId, now) {
 export function setSummary(sessionId, summary) {
     return updateState(sessionId, { summary });
 }
+export function setNotify(sessionId, notify) {
+    return updateState(sessionId, { notify });
+}
 export function addTask(sessionId, taskDescription, status = 'todo') {
     const state = loadState(sessionId);
     validateTask(taskDescription);
@@ -113,3 +116,45 @@ export function setTasks(sessionId, taskDescriptions) {
     });
     return updateState(sessionId, { tasks });
 }
+/**
+ * Set ask state with question and optional clickable options.
+ * This is the new unified command that sets state=ask AND stores the question.
+ */
+export function setAsk(sessionId, question, optionStrings) {
+    const state = loadState(sessionId);
+    // Validate inputs
+    validateAsk(question);
+    const options = optionStrings ? validateAskOptions(optionStrings) : undefined;
+    // Set state and question
+    state.state = 'ask';
+    state.ask = question;
+    state.askOptions = options;
+    // Also set legacy fields for backwards compatibility
+    state.question = question;
+    state.notify = question;
+    // Clear done field since we're back to asking
+    delete state.done;
+    saveState(state);
+    return state;
+}
+/**
+ * Set done state with result summary.
+ * This is the new unified command that sets state=done AND stores the summary.
+ */
+export function setDone(sessionId, summary) {
+    const state = loadState(sessionId);
+    // Validate input
+    validateDone(summary);
+    // Set state and summary
+    state.state = 'done';
+    state.done = summary;
+    // Also set legacy fields for backwards compatibility
+    state.summary = summary;
+    state.notify = summary;
+    // Clear ask fields since we're done
+    delete state.ask;
+    delete state.askOptions;
+    delete state.question;
+    saveState(state);
+    return state;
+}

package/dist/types.d.ts

@@ -4,13 +4,25 @@ export interface Task {
     task: string;
     status: TaskStatus;
 }
+/**
+ * An option for ask questions with clickable choices
+ * Format in CLI: "Name: Description" or just "Name"
+ */
+export interface AskOption {
+    name: string;
+    desc?: string;
+}
 export interface ZergState {
     session: string;
     name?: string;
     state: State;
     now: string;
-    summary: string;
+    ask?: string;
+    askOptions?: AskOption[];
+    done?: string;
     tasks: Task[];
+    summary?: string;
     question?: string;
+    notify?: string;
 }
 export declare const DEFAULT_STATE: Omit<ZergState, 'session'>;

package/dist/types.js

@@ -1,6 +1,5 @@
 export const DEFAULT_STATE = {
     state: 'work',
     now: '',
-    summary: '',
     tasks: [],
 };

package/dist/validate.d.ts

@@ -1,4 +1,4 @@
-import type { State, TaskStatus } from './types.js';
+import type { State, TaskStatus, AskOption } from './types.js';
 export declare const VALID_STATES: State[];
 export declare const VALID_TASK_STATUSES: TaskStatus[];
 export declare const MAX_NOW_LENGTH = 50;
@@ -7,6 +7,13 @@ export declare const MAX_TASK_LENGTH = 200;
 export declare const MAX_TASKS = 20;
 export declare const MAX_NAME_LENGTH = 60;
 export declare const MAX_NAME_WORDS = 6;
+export declare const MAX_NOTIFY_LENGTH = 150;
+export declare const MAX_ASK_LENGTH = 150;
+export declare const MAX_DONE_LENGTH = 200;
+export declare const MIN_OPTIONS = 2;
+export declare const MAX_OPTIONS = 5;
+export declare const MAX_OPTION_NAME_LENGTH = 30;
+export declare const MAX_OPTION_DESC_LENGTH = 50;
 export declare class ValidationError extends Error {
     constructor(message: string);
 }
@@ -14,7 +21,24 @@ export declare function validateState(state: string): State;
 export declare function validateTaskStatus(status: string): TaskStatus;
 export declare function validateNow(now: string): string;
 export declare function validateSummary(summary: string): string;
+export declare function validateNotify(notify: string): string;
 export declare function validateTask(task: string): string;
 export declare function validateTaskCount(count: number): void;
 export declare function validateSessionId(sessionId: string | undefined): string;
 export declare function validateName(name: string): string;
+/**
+ * Validates the ask question text
+ */
+export declare function validateAsk(ask: string): string;
+/**
+ * Validates the done summary text
+ */
+export declare function validateDone(done: string): string;
+/**
+ * Parses an option string in the format "Name: Description" or just "Name"
+ */
+export declare function parseOption(optionStr: string): AskOption;
+/**
+ * Validates and parses ask options
+ */
+export declare function validateAskOptions(optionStrings: string[]): AskOption[];

package/dist/validate.js

@@ -6,6 +6,14 @@ export const MAX_TASK_LENGTH = 200;
 export const MAX_TASKS = 20;
 export const MAX_NAME_LENGTH = 60;
 export const MAX_NAME_WORDS = 6;
+export const MAX_NOTIFY_LENGTH = 150;
+// Ask/Done validation
+export const MAX_ASK_LENGTH = 150;
+export const MAX_DONE_LENGTH = 200;
+export const MIN_OPTIONS = 2;
+export const MAX_OPTIONS = 5;
+export const MAX_OPTION_NAME_LENGTH = 30;
+export const MAX_OPTION_DESC_LENGTH = 50;
 export class ValidationError extends Error {
     constructor(message) {
         super(message);
@@ -36,6 +44,12 @@ export function validateSummary(summary) {
     }
     return summary;
 }
+export function validateNotify(notify) {
+    if (notify.length > MAX_NOTIFY_LENGTH) {
+        throw new ValidationError(`Notify text too long (${notify.length} chars). Max ${MAX_NOTIFY_LENGTH} chars.`);
+    }
+    return notify;
+}
 export function validateTask(task) {
     if (task.length > MAX_TASK_LENGTH) {
         throw new ValidationError(`Task too long (${task.length} chars). Max ${MAX_TASK_LENGTH} chars.`);
@@ -63,3 +77,59 @@ export function validateName(name) {
     }
     return name;
 }
+/**
+ * Validates the ask question text
+ */
+export function validateAsk(ask) {
+    if (ask.length > MAX_ASK_LENGTH) {
+        throw new ValidationError(`Ask text too long (${ask.length} chars). Max ${MAX_ASK_LENGTH} chars.`);
+    }
+    return ask;
+}
+/**
+ * Validates the done summary text
+ */
+export function validateDone(done) {
+    if (done.length > MAX_DONE_LENGTH) {
+        throw new ValidationError(`Done text too long (${done.length} chars). Max ${MAX_DONE_LENGTH} chars.`);
+    }
+    return done;
+}
+/**
+ * Parses an option string in the format "Name: Description" or just "Name"
+ */
+export function parseOption(optionStr) {
+    const colonIndex = optionStr.indexOf(':');
+    if (colonIndex === -1) {
+        // Just a name, no description
+        const name = optionStr.trim();
+        if (name.length > MAX_OPTION_NAME_LENGTH) {
+            throw new ValidationError(`Option name too long (${name.length} chars). Max ${MAX_OPTION_NAME_LENGTH} chars.`);
+        }
+        return { name };
+    }
+    const name = optionStr.slice(0, colonIndex).trim();
+    const desc = optionStr.slice(colonIndex + 1).trim();
+    if (name.length > MAX_OPTION_NAME_LENGTH) {
+        throw new ValidationError(`Option name "${name}" too long (${name.length} chars). Max ${MAX_OPTION_NAME_LENGTH} chars.`);
+    }
+    if (desc.length > MAX_OPTION_DESC_LENGTH) {
+        throw new ValidationError(`Option description too long (${desc.length} chars). Max ${MAX_OPTION_DESC_LENGTH} chars.`);
+    }
+    return { name, desc: desc || undefined };
+}
+/**
+ * Validates and parses ask options
+ */
+export function validateAskOptions(optionStrings) {
+    if (optionStrings.length === 0) {
+        return [];
+    }
+    if (optionStrings.length < MIN_OPTIONS) {
+        throw new ValidationError(`Too few options (${optionStrings.length}). Min ${MIN_OPTIONS} options.`);
+    }
+    if (optionStrings.length > MAX_OPTIONS) {
+        throw new ValidationError(`Too many options (${optionStrings.length}). Max ${MAX_OPTIONS} options.`);
+    }
+    return optionStrings.map(parseOption);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zerg-status",
-  "version": "1.1.0",
+  "version": "2.0.0",
   "description": "Progress reporting CLI for Zerg dashboard",
   "type": "module",
   "bin": {