gsd-unsupervised 1.0.0

package/dist/git.js

@@ -0,0 +1,76 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { simpleGit } from 'simple-git';
+const execFileP = promisify(execFile);
+/**
+ * Returns true if git working tree has no uncommitted changes (clean).
+ * Runs `git status --porcelain` in workspaceRoot; empty output = clean.
+ */
+export async function isWorkingTreeClean(workspaceRoot, options) {
+    try {
+        const { stdout } = await execFileP('git', ['status', '--porcelain'], {
+            cwd: workspaceRoot,
+            encoding: 'utf-8',
+        });
+        const ignore = new Set((options?.ignorePaths ?? []).map(normalizeGitPath));
+        const entries = stdout
+            .split('\n')
+            .map((l) => l.trimEnd())
+            .filter((l) => l.trim().length > 0);
+        if (entries.length === 0)
+            return true;
+        for (const line of entries) {
+            const paths = extractPorcelainPaths(line).map(normalizeGitPath);
+            const allIgnored = paths.length > 0 && paths.every((p) => ignore.has(p));
+            if (!allIgnored)
+                return false;
+        }
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function normalizeGitPath(p) {
+    // git always reports paths with forward slashes; normalize just in case.
+    return p.replace(/\\/g, '/');
+}
+/**
+ * Extracts one or two paths from a `git status --porcelain` line.
+ * Handles normal entries: " M path", "?? path", and renames: "R  old -> new".
+ */
+function extractPorcelainPaths(line) {
+    // Porcelain v1: first 2 chars are status, then a space, then path(s).
+    const rest = line.length >= 4 ? line.slice(3).trim() : line.trim();
+    if (rest.includes('->')) {
+        const [from, to] = rest.split('->').map((s) => s.trim());
+        return [from, to].filter(Boolean);
+    }
+    return rest ? [rest] : [];
+}
+/**
+ * Creates a checkpoint commit: git add -A && git commit -m message.
+ * Use when autoCheckpoint is true and tree is dirty before execute-plan.
+ */
+export async function createCheckpoint(workspaceRoot, message) {
+    await execFileP('git', ['add', '-A'], { cwd: workspaceRoot });
+    await execFileP('git', ['commit', '-m', message], { cwd: workspaceRoot });
+}
+/**
+ * Returns the last N commits (hash, message, timestamp) for dashboard/API.
+ * Uses simple-git. Returns [] on error or not a git repo.
+ */
+export async function getRecentCommits(workspaceRoot, limit = 10) {
+    try {
+        const git = simpleGit(workspaceRoot);
+        const log = await git.log({ maxCount: limit });
+        return log.all.map((c) => ({
+            hash: c.hash,
+            message: c.message,
+            timestamp: typeof c.date === 'string' ? c.date : c.date.toISOString(),
+        }));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/goals.d.ts

@@ -0,0 +1,34 @@
+export interface Goal {
+    title: string;
+    status: 'pending' | 'in_progress' | 'done';
+    raw: string;
+    /**
+     * Optional parallelization metadata parsed from annotations in the raw
+     * markdown line. These fields are purely advisory and are interpreted by
+     * the execution planner in the daemon.
+     */
+    parallelGroup?: string | null;
+    dependsOn?: string[];
+    priority?: number;
+}
+export declare function parseGoals(markdown: string): Goal[];
+export declare function loadGoals(filePath: string): Promise<Goal[]>;
+export declare function getPendingGoals(goals: Goal[]): Goal[];
+/**
+ * Appends a new pending goal to goals.md (under ## Pending).
+ * Used by webhook and hot-reload merge; does not deduplicate.
+ */
+export declare function appendPendingGoal(goalsPath: string, title: string, priority?: number): Promise<void>;
+export interface ExecutionPlanItem {
+    goal: Goal;
+    parallelGroup?: string | null;
+    dependsOn: string[];
+    priority: number;
+}
+export interface ExecutionPlan {
+    /** Flattened list of goals in execution order. */
+    ordered: Goal[];
+    /** Grouped view for potential future parallel scheduling. */
+    items: ExecutionPlanItem[];
+}
+export declare function buildExecutionPlan(goals: Goal[]): ExecutionPlan;

package/dist/goals.js

@@ -0,0 +1,148 @@
+import { readFile, writeFile } from 'node:fs/promises';
+const SECTION_MAP = {
+    '## pending': 'pending',
+    '## in progress': 'in_progress',
+    '## done': 'done',
+};
+const CHECKBOX_RE = /^- \[([ xX])\]\s+(.+)$/;
+export function parseGoals(markdown) {
+    const normalized = markdown.replace(/\r\n/g, '\n');
+    const lines = normalized.split('\n');
+    const goals = [];
+    let currentStatus = null;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        const lower = trimmed.toLowerCase();
+        if (SECTION_MAP[lower] !== undefined) {
+            currentStatus = SECTION_MAP[lower];
+            continue;
+        }
+        if (currentStatus === null)
+            continue;
+        const match = trimmed.match(CHECKBOX_RE);
+        if (!match)
+            continue;
+        const title = match[2].trim();
+        const annotated = applyAnnotations({
+            title,
+            status: currentStatus,
+            raw: trimmed,
+        });
+        goals.push(annotated);
+    }
+    return goals;
+}
+export async function loadGoals(filePath) {
+    let content;
+    try {
+        content = await readFile(filePath, 'utf-8');
+    }
+    catch (err) {
+        if (err instanceof Error && 'code' in err && err.code === 'ENOENT') {
+            throw new Error(`Goals file not found: ${filePath}`);
+        }
+        throw err;
+    }
+    if (content.trim().length === 0)
+        return [];
+    const goals = parseGoals(content);
+    if (getPendingGoals(goals).length === 0) {
+        console.warn(`Warning: no pending goals found in ${filePath}`);
+    }
+    return goals;
+}
+export function getPendingGoals(goals) {
+    return goals.filter((g) => g.status === 'pending');
+}
+/**
+ * Appends a new pending goal to goals.md (under ## Pending).
+ * Used by webhook and hot-reload merge; does not deduplicate.
+ */
+export async function appendPendingGoal(goalsPath, title, priority) {
+    const content = await readFile(goalsPath, 'utf-8');
+    const lines = content.split(/\r?\n/);
+    const pendingHeader = '## pending';
+    let insertIndex = -1;
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].trim().toLowerCase() === pendingHeader) {
+            insertIndex = i + 1;
+            break;
+        }
+    }
+    if (insertIndex < 0) {
+        throw new Error(`Goals file missing "${pendingHeader}" section: ${goalsPath}`);
+    }
+    const suffix = Number.isFinite(priority) ? ` [priority:${priority}]` : '';
+    const newLine = `- [ ] ${title}${suffix}`;
+    lines.splice(insertIndex, 0, newLine);
+    await writeFile(goalsPath, lines.join('\n'), 'utf-8');
+}
+/**
+ * Lightweight annotation grammar for goals:
+ *
+ *   - [ ] Title text [group:alpha] [after:beta,gamma] [priority:1]
+ *
+ * The bracketed tokens can appear anywhere in the line; they are stripped
+ * from the human-readable title but preserved as structured metadata.
+ */
+function applyAnnotations(base) {
+    const GROUP_RE = /\[group:([^[\]]+)\]/i;
+    const AFTER_RE = /\[after:([^[\]]+)\]/i;
+    const PRIORITY_RE = /\[priority:(\d+)\]/i;
+    let title = base.title;
+    let parallelGroup;
+    let dependsOn;
+    let priority;
+    const groupMatch = title.match(GROUP_RE);
+    if (groupMatch) {
+        parallelGroup = groupMatch[1].trim();
+        title = title.replace(GROUP_RE, '').trim();
+    }
+    const afterMatch = title.match(AFTER_RE);
+    if (afterMatch) {
+        dependsOn = afterMatch[1]
+            .split(',')
+            .map((s) => s.trim())
+            .filter(Boolean);
+        title = title.replace(AFTER_RE, '').trim();
+    }
+    const priorityMatch = title.match(PRIORITY_RE);
+    if (priorityMatch) {
+        const p = Number.parseInt(priorityMatch[1], 10);
+        if (Number.isFinite(p)) {
+            priority = p;
+        }
+        title = title.replace(PRIORITY_RE, '').trim();
+    }
+    return {
+        ...base,
+        title,
+        parallelGroup,
+        dependsOn,
+        priority,
+    };
+}
+export function buildExecutionPlan(goals) {
+    // Prioritization: sort by explicit [priority:N] (asc), then by original order.
+    // parallelGroup and dependsOn are exposed on items but are not used by the
+    // daemon for scheduling — goals are always processed one at a time in this order.
+    // For now we keep semantics simple and stable; backwards-compatible for existing queues.
+    const itemsWithIndex = goals.map((goal, index) => ({
+        goal,
+        parallelGroup: goal.parallelGroup ?? null,
+        dependsOn: goal.dependsOn ?? [],
+        priority: Number.isFinite(goal.priority ?? NaN)
+            ? goal.priority
+            : Number.MAX_SAFE_INTEGER,
+        index,
+    }));
+    itemsWithIndex.sort((a, b) => {
+        if (a.priority !== b.priority)
+            return a.priority - b.priority;
+        return a.index - b.index;
+    });
+    return {
+        ordered: itemsWithIndex.map((i) => i.goal),
+        items: itemsWithIndex.map(({ index, ...rest }) => rest),
+    };
+}

package/dist/gsd-state.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Single source of truth for gsd-unsupervised daemon state.
+ * Lives at <workspaceRoot>/.gsd/state.json so ./run can resume reliably.
+ */
+export type GsdMode = 'self' | 'project';
+export interface GsdState {
+    mode: GsdMode;
+    /** Project name (e.g. "gsd-unsupervised" or "my-other-app"). */
+    project: string;
+    /** Absolute or relative path to workspace root (where .planning/ and goals live). */
+    workspaceRoot: string;
+    /** Path to goals.md relative to workspaceRoot or absolute. */
+    goalsPath: string;
+    /** Daemon process ID (set when daemon starts). */
+    daemonPid?: number;
+    /** ISO timestamp when daemon started. */
+    startedAt?: string;
+    /** Last completed goal title (for display). */
+    lastGoalCompleted?: string;
+    /** Progress string e.g. "2/9". */
+    progress?: string;
+    /** Status server port (e.g. 3000). */
+    statusServerPort?: number;
+    /** Public dashboard URL from ngrok (ephemeral). */
+    ngrokUrl?: string;
+    /** ISO timestamp of last heartbeat (for SMS pulse check). */
+    lastHeartbeat?: string;
+    /** Current goal title while running. */
+    currentGoal?: string;
+}
+/**
+ * Resolve state file path: <workspaceRoot>/.gsd/state.json.
+ * If stateDir is provided it's the directory containing state.json.
+ */
+export declare function getStatePath(workspaceRoot: string): string;
+/**
+ * Read state from .gsd/state.json in workspaceRoot. Returns null if missing or invalid.
+ */
+export declare function readGsdState(workspaceRoot: string): Promise<GsdState | null>;
+/**
+ * Read state from an absolute path to state.json. Default workspaceRoot if not in file.
+ */
+export declare function readGsdStateFromPath(statePath: string, defaultWorkspaceRoot?: string): Promise<GsdState | null>;
+/**
+ * Write state to .gsd/state.json. Creates .gsd/ if needed.
+ * Partial update: only provided fields are merged in.
+ * If statePath is provided, write there; otherwise use getStatePath(workspaceRoot).
+ */
+export declare function writeGsdState(workspaceRoot: string, update: Partial<GsdState>, statePath?: string): Promise<void>;

package/dist/gsd-state.js

@@ -0,0 +1,76 @@
+/**
+ * Single source of truth for gsd-unsupervised daemon state.
+ * Lives at <workspaceRoot>/.gsd/state.json so ./run can resume reliably.
+ */
+import { readFile, writeFile, mkdir } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { dirname } from 'node:path';
+const DEFAULT_STATE = {
+    mode: 'self',
+    goalsPath: './goals.md',
+};
+/**
+ * Resolve state file path: <workspaceRoot>/.gsd/state.json.
+ * If stateDir is provided it's the directory containing state.json.
+ */
+export function getStatePath(workspaceRoot) {
+    return `${workspaceRoot.replace(/\/$/, '')}/.gsd/state.json`;
+}
+/**
+ * Read state from .gsd/state.json in workspaceRoot. Returns null if missing or invalid.
+ */
+export async function readGsdState(workspaceRoot) {
+    const path = getStatePath(workspaceRoot);
+    return readGsdStateFromPath(path, workspaceRoot);
+}
+/**
+ * Read state from an absolute path to state.json. Default workspaceRoot if not in file.
+ */
+export async function readGsdStateFromPath(statePath, defaultWorkspaceRoot) {
+    if (!existsSync(statePath))
+        return null;
+    const fallbackRoot = defaultWorkspaceRoot ?? dirname(dirname(statePath));
+    try {
+        const raw = await readFile(statePath, 'utf-8');
+        const data = JSON.parse(raw);
+        return {
+            mode: (data.mode === 'project' ? 'project' : 'self'),
+            project: typeof data.project === 'string' ? data.project : 'gsd-unsupervised',
+            workspaceRoot: typeof data.workspaceRoot === 'string' ? data.workspaceRoot : fallbackRoot,
+            goalsPath: typeof data.goalsPath === 'string' ? data.goalsPath : './goals.md',
+            daemonPid: typeof data.daemonPid === 'number' ? data.daemonPid : undefined,
+            startedAt: typeof data.startedAt === 'string' ? data.startedAt : undefined,
+            lastGoalCompleted: typeof data.lastGoalCompleted === 'string' ? data.lastGoalCompleted : undefined,
+            progress: typeof data.progress === 'string' ? data.progress : undefined,
+            statusServerPort: typeof data.statusServerPort === 'number' ? data.statusServerPort : undefined,
+            ngrokUrl: typeof data.ngrokUrl === 'string' ? data.ngrokUrl : undefined,
+            lastHeartbeat: typeof data.lastHeartbeat === 'string' ? data.lastHeartbeat : undefined,
+            currentGoal: typeof data.currentGoal === 'string' ? data.currentGoal : undefined,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Write state to .gsd/state.json. Creates .gsd/ if needed.
+ * Partial update: only provided fields are merged in.
+ * If statePath is provided, write there; otherwise use getStatePath(workspaceRoot).
+ */
+export async function writeGsdState(workspaceRoot, update, statePath) {
+    const path = statePath ?? getStatePath(workspaceRoot);
+    const dir = dirname(path);
+    await mkdir(dir, { recursive: true });
+    const existing = statePath
+        ? await readGsdStateFromPath(path, workspaceRoot)
+        : await readGsdState(workspaceRoot);
+    const merged = {
+        mode: existing?.mode ?? DEFAULT_STATE.mode,
+        project: existing?.project ?? 'gsd-unsupervised',
+        workspaceRoot: existing?.workspaceRoot ?? workspaceRoot,
+        goalsPath: existing?.goalsPath ?? DEFAULT_STATE.goalsPath,
+        ...existing,
+        ...update,
+    };
+    await writeFile(path, JSON.stringify(merged, null, 2), 'utf-8');
+}

package/dist/init-wizard.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Onboarding wizard for gsd-unsupervised: one command, minimal questions.
+ * Writes .gsd/state.json, goals (goals.md or .gsd/goals.md), .env, and config.
+ */
+export declare function runInit(): Promise<void>;

package/dist/init-wizard.js

@@ -0,0 +1,96 @@
+/**
+ * Onboarding wizard for gsd-unsupervised: one command, minimal questions.
+ * Writes .gsd/state.json, goals (goals.md or .gsd/goals.md), .env, and config.
+ */
+import { createInterface } from 'node:readline';
+import { writeFile, mkdir, readFile } from 'node:fs/promises';
+import { existsSync } from 'node:fs';
+import { resolve, dirname as pathDirname } from 'node:path';
+import { writeGsdState } from './gsd-state.js';
+function ask(rl, question) {
+    return new Promise((res) => {
+        rl.question(question, (answer) => res((answer ?? '').trim()));
+    });
+}
+function askYesNo(rl, question) {
+    return new Promise((res) => {
+        rl.question(question, (answer) => {
+            const a = (answer ?? '').trim().toLowerCase();
+            res(a === 'y' || a === 'yes' || a === '1');
+        });
+    });
+}
+export async function runInit() {
+    const cwd = process.cwd();
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    console.log('\n  gsd-unsupervised init\n');
+    const name = await ask(rl, "? What's this project? (name) ");
+    const projectName = name || 'my-project';
+    const repoPrompt = await ask(rl, "? Where's the repo? (path or git URL, or Enter for current dir) ");
+    const repoPath = repoPrompt || '.';
+    const firstGoal = await ask(rl, "? What's your first goal? (freetext) ");
+    const goalText = firstGoal ? `- [ ] ${firstGoal}` : '- [ ] Get started with GSD';
+    const twilio = await askYesNo(rl, '? Twilio SMS alerts? (y/n) ');
+    const ngrok = await askYesNo(rl, '? Public dashboard via ngrok? (y/n) ');
+    rl.close();
+    const workspaceRoot = resolve(cwd, repoPath);
+    const gsdDir = resolve(workspaceRoot, '.gsd');
+    await mkdir(gsdDir, { recursive: true });
+    let isSelf = false;
+    try {
+        const pkg = JSON.parse(await readFile(resolve(workspaceRoot, 'package.json'), 'utf-8'));
+        isSelf = pkg.name === 'gsd-unsupervised';
+    }
+    catch {
+        // not this repo or no package.json
+    }
+    const mode = isSelf ? 'self' : 'project';
+    const goalsPath = mode === 'project' ? '.gsd/goals.md' : './goals.md';
+    const state = {
+        mode,
+        project: projectName,
+        workspaceRoot,
+        goalsPath,
+        statusServerPort: 3000,
+        ...(ngrok && { ngrokUrl: '' }),
+    };
+    const statePath = resolve(gsdDir, 'state.json');
+    await writeGsdState(workspaceRoot, state, statePath);
+    const goalsFile = resolve(workspaceRoot, goalsPath);
+    const goalsContent = `# GSD Autopilot Goals Queue
+
+## Pending
+${goalText}
+
+## In Progress
+<!-- orchestrator moves goals here while running -->
+
+## Done
+<!-- orchestrator moves goals here on completion -->
+`;
+    await mkdir(pathDirname(goalsFile), { recursive: true }).catch(() => { });
+    await writeFile(goalsFile, goalsContent, 'utf-8');
+    const envPath = resolve(workspaceRoot, '.env');
+    let envLines = [];
+    if (existsSync(envPath)) {
+        const raw = await readFile(envPath, 'utf-8');
+        envLines = raw.split('\n').filter((l) => !l.startsWith('TWILIO_'));
+    }
+    if (twilio) {
+        envLines.push('# Twilio SMS (fill in values)');
+        envLines.push('TWILIO_ACCOUNT_SID=');
+        envLines.push('TWILIO_AUTH_TOKEN=');
+        envLines.push('TWILIO_FROM=');
+        envLines.push('TWILIO_TO=');
+    }
+    if (envLines.length > 0) {
+        await writeFile(envPath, envLines.join('\n') + '\n', 'utf-8');
+    }
+    if (ngrok) {
+        const configPath = resolve(gsdDir, 'config.json');
+        await writeFile(configPath, JSON.stringify({ useNgrok: true, statusServerPort: 3000 }, null, 2), 'utf-8');
+    }
+    console.log('\n  ✓ Created .gsd/ config');
+    console.log('  ✓ Created goals with your first goal');
+    console.log('  ✓ Run: ./run to start\n');
+}

package/dist/lifecycle.d.ts

@@ -0,0 +1,41 @@
+export declare enum GoalLifecyclePhase {
+    New = "new",
+    InitializingProject = "initializing_project",
+    CreatingRoadmap = "creating_roadmap",
+    PlanningPhase = "planning_phase",
+    ExecutingPlan = "executing_plan",
+    PhaseComplete = "phase_complete",
+    Complete = "complete",
+    Failed = "failed"
+}
+export interface GsdCommand {
+    command: string;
+    args?: string;
+    description: string;
+}
+export interface GoalProgress {
+    goalTitle: string;
+    phase: GoalLifecyclePhase;
+    currentPhaseNumber: number;
+    totalPhases: number;
+    currentPlanIndex: number;
+    totalPlansInPhase: number;
+    lastCommand?: GsdCommand;
+    error?: string;
+}
+export declare const LIFECYCLE_TRANSITIONS: Record<GoalLifecyclePhase, GoalLifecyclePhase[]>;
+export declare class GoalStateMachine {
+    private progress;
+    constructor(goalTitle: string);
+    getProgress(): GoalProgress;
+    getPhase(): GoalLifecyclePhase;
+    isComplete(): boolean;
+    isFailed(): boolean;
+    isTerminal(): boolean;
+    advance(to: GoalLifecyclePhase): void;
+    setPhaseInfo(currentPhase: number, totalPhases: number): void;
+    setPlanInfo(currentPlan: number, totalPlans: number): void;
+    getNextCommand(): GsdCommand | null;
+    fail(error: string): void;
+    setLastCommand(cmd: GsdCommand): void;
+}

package/dist/lifecycle.js

@@ -0,0 +1,103 @@
+export var GoalLifecyclePhase;
+(function (GoalLifecyclePhase) {
+    GoalLifecyclePhase["New"] = "new";
+    GoalLifecyclePhase["InitializingProject"] = "initializing_project";
+    GoalLifecyclePhase["CreatingRoadmap"] = "creating_roadmap";
+    GoalLifecyclePhase["PlanningPhase"] = "planning_phase";
+    GoalLifecyclePhase["ExecutingPlan"] = "executing_plan";
+    GoalLifecyclePhase["PhaseComplete"] = "phase_complete";
+    GoalLifecyclePhase["Complete"] = "complete";
+    GoalLifecyclePhase["Failed"] = "failed";
+})(GoalLifecyclePhase || (GoalLifecyclePhase = {}));
+export const LIFECYCLE_TRANSITIONS = {
+    [GoalLifecyclePhase.New]: [GoalLifecyclePhase.InitializingProject],
+    [GoalLifecyclePhase.InitializingProject]: [GoalLifecyclePhase.CreatingRoadmap],
+    [GoalLifecyclePhase.CreatingRoadmap]: [GoalLifecyclePhase.PlanningPhase],
+    [GoalLifecyclePhase.PlanningPhase]: [GoalLifecyclePhase.ExecutingPlan, GoalLifecyclePhase.PhaseComplete],
+    [GoalLifecyclePhase.ExecutingPlan]: [GoalLifecyclePhase.ExecutingPlan, GoalLifecyclePhase.PhaseComplete],
+    [GoalLifecyclePhase.PhaseComplete]: [GoalLifecyclePhase.PlanningPhase, GoalLifecyclePhase.Complete],
+    [GoalLifecyclePhase.Complete]: [],
+    [GoalLifecyclePhase.Failed]: [],
+};
+export class GoalStateMachine {
+    progress;
+    constructor(goalTitle) {
+        this.progress = {
+            goalTitle,
+            phase: GoalLifecyclePhase.New,
+            currentPhaseNumber: 0,
+            totalPhases: 0,
+            currentPlanIndex: 0,
+            totalPlansInPhase: 0,
+        };
+    }
+    getProgress() {
+        return { ...this.progress };
+    }
+    getPhase() {
+        return this.progress.phase;
+    }
+    isComplete() {
+        return this.progress.phase === GoalLifecyclePhase.Complete;
+    }
+    isFailed() {
+        return this.progress.phase === GoalLifecyclePhase.Failed;
+    }
+    isTerminal() {
+        return this.isComplete() || this.isFailed();
+    }
+    advance(to) {
+        const allowed = LIFECYCLE_TRANSITIONS[this.progress.phase];
+        if (!allowed.includes(to)) {
+            throw new Error(`Invalid transition: ${this.progress.phase} → ${to}. ` +
+                `Allowed transitions from '${this.progress.phase}': [${allowed.join(', ')}]`);
+        }
+        this.progress.phase = to;
+    }
+    setPhaseInfo(currentPhase, totalPhases) {
+        this.progress.currentPhaseNumber = currentPhase;
+        this.progress.totalPhases = totalPhases;
+    }
+    setPlanInfo(currentPlan, totalPlans) {
+        this.progress.currentPlanIndex = currentPlan;
+        this.progress.totalPlansInPhase = totalPlans;
+    }
+    getNextCommand() {
+        switch (this.progress.phase) {
+            case GoalLifecyclePhase.New:
+                return { command: '/gsd/new-project', description: 'Initialize project' };
+            case GoalLifecyclePhase.InitializingProject:
+                return { command: '/gsd/create-roadmap', description: 'Create roadmap' };
+            case GoalLifecyclePhase.CreatingRoadmap:
+                return {
+                    command: '/gsd/plan-phase',
+                    args: String(this.progress.currentPhaseNumber),
+                    description: `Plan phase ${this.progress.currentPhaseNumber}`,
+                };
+            case GoalLifecyclePhase.PlanningPhase:
+                return null;
+            case GoalLifecyclePhase.ExecutingPlan:
+                return null;
+            case GoalLifecyclePhase.PhaseComplete:
+                if (this.progress.currentPhaseNumber < this.progress.totalPhases) {
+                    const next = this.progress.currentPhaseNumber + 1;
+                    return {
+                        command: '/gsd/plan-phase',
+                        args: String(next),
+                        description: `Plan phase ${next}`,
+                    };
+                }
+                return null;
+            case GoalLifecyclePhase.Complete:
+            case GoalLifecyclePhase.Failed:
+                return null;
+        }
+    }
+    fail(error) {
+        this.progress.phase = GoalLifecyclePhase.Failed;
+        this.progress.error = error;
+    }
+    setLastCommand(cmd) {
+        this.progress.lastCommand = { ...cmd };
+    }
+}

package/dist/lifecycle.test.d.ts

@@ -0,0 +1 @@
+export {};