gsd-unsupervised 1.0.0 → 1.0.1

package/README.md

@@ -244,7 +244,7 @@ Resume uses this to re-run `execute-plan` for phase 2 plan 1 only, then continue
 
 **Parallel goal pool:** With `--parallel`, a worker pool of size `--max-concurrent` is used; a per-workspace mutex keeps one goal running at a time for a single workspace (phase-level parallel inside execute-phase still applies).
 
-**SMS (Twilio):** Optional. Set `TWILIO_ACCOUNT_SID`, `TWILIO_AUTH_TOKEN`, `TWILIO_FROM`, and `TWILIO_TO` to receive SMS on goal complete, goal failed, and daemon paused (after 3 retries). If any are unset, SMS is skipped and the daemon runs normally.
+**SMS (Twilio):** Optional. Set `TWILIO_ACCOUNT_SID`, `TWILIO_AUTH_TOKEN`, `TWILIO_FROM`, and `TWILIO_TO` to receive SMS on goal complete, goal failed, and daemon paused (after 3 retries). If any are unset, SMS is skipped and the daemon runs normally. To verify delivery, run `npx gsd-unsupervised test-sms` from the project root (after `npm run build`).
 
 **State and heartbeat:** When started via `./run` or `gsd-unsupervised run --state .gsd/state.json`, the daemon writes to `.gsd/state.json` (PID, current goal, progress, `lastHeartbeat`). You can use `lastHeartbeat` in an external cron or script to send a periodic "alive" SMS (e.g. every 30 min) or alert if the heartbeat is stale (e.g. >10 min).
 

package/dist/cli.js

@@ -9,6 +9,7 @@ import { loadConfig } from './config.js';
 import { loadGoals, getPendingGoals } from './goals.js';
 import { runDaemon, registerShutdownHandlers } from './daemon.js';
 import { validateCursorApiKey } from './cursor-agent.js';
+import { sendSms } from './notifier.js';
 import { applyWslBootstrap } from './bootstrap/wsl-bootstrap.js';
 import { readGsdStateFromPath } from './gsd-state.js';
 const __filename = fileURLToPath(import.meta.url);
@@ -166,6 +167,26 @@ program
     const { runInit } = await import('./init-wizard.js');
     await runInit();
 });
+/** Send a test SMS to verify Twilio config (TWILIO_* in .env or env). */
+program
+    .command('test-sms')
+    .description('Send a test SMS to verify Twilio credentials and delivery')
+    .option('--message <text>', 'Custom message (default: GSD Autopilot test message)', undefined)
+    .action(async (opts) => {
+    const message = opts.message?.trim() ||
+        'GSD Autopilot test SMS. If you received this, notifications are working.';
+    try {
+        await sendSms(message);
+        console.log('Test SMS sent successfully. Check your phone (TWILIO_TO).');
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.error('Failed to send test SMS:', msg);
+        console.error('');
+        console.error('Check: TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, TWILIO_FROM, TWILIO_TO in .env or environment.');
+        process.exit(1);
+    }
+});
 export function main() {
     program.parse();
 }

package/dist/config.d.ts

@@ -6,14 +6,18 @@ export declare const AutopilotConfigSchema: z.ZodObject<{
     maxConcurrent: z.ZodDefault<z.ZodNumber>;
     /**
      * Upper bound on allowed CPU usage before new agent work waits.
-     * Expressed as a fraction of total CPU capacity (1.0 = 100% of all cores).
+     * Expressed as a fraction of total CPU capacity (1.0 = 100%). 0.8 = 80% recommended for parallel.
      */
     maxCpuFraction: z.ZodDefault<z.ZodNumber>;
     /**
      * Upper bound on allowed memory usage before new agent work waits.
-     * Expressed as a fraction of total system memory (1.0 = 100% of RAM).
+     * Expressed as a fraction of total system memory (1.0 = 100%). 0.8 = 80% recommended for parallel.
      */
     maxMemoryFraction: z.ZodDefault<z.ZodNumber>;
+    /**
+     * Upper bound on GPU utilization (0–1) when nvidia-smi is available. 0.8 = 80% recommended for parallel.
+     */
+    maxGpuFraction: z.ZodOptional<z.ZodNumber>;
     verbose: z.ZodDefault<z.ZodBoolean>;
     logLevel: z.ZodDefault<z.ZodEnum<["debug", "info", "warn", "error"]>>;
     workspaceRoot: z.ZodDefault<z.ZodString>;
@@ -50,6 +54,7 @@ export declare const AutopilotConfigSchema: z.ZodObject<{
     requireCleanGitBeforePlan: boolean;
     autoCheckpoint: boolean;
     ngrok: boolean;
+    maxGpuFraction?: number | undefined;
     statusServerPort?: number | undefined;
     statePath?: string | undefined;
 }, {
@@ -58,6 +63,7 @@ export declare const AutopilotConfigSchema: z.ZodObject<{
     maxConcurrent?: number | undefined;
     maxCpuFraction?: number | undefined;
     maxMemoryFraction?: number | undefined;
+    maxGpuFraction?: number | undefined;
     verbose?: boolean | undefined;
     logLevel?: "error" | "warn" | "info" | "debug" | undefined;
     workspaceRoot?: string | undefined;

package/dist/config.js

@@ -9,14 +9,18 @@ export const AutopilotConfigSchema = z.object({
     maxConcurrent: z.number().int().min(1).max(10).default(3),
     /**
      * Upper bound on allowed CPU usage before new agent work waits.
-     * Expressed as a fraction of total CPU capacity (1.0 = 100% of all cores).
+     * Expressed as a fraction of total CPU capacity (1.0 = 100%). 0.8 = 80% recommended for parallel.
      */
-    maxCpuFraction: z.number().min(0.1).max(1).default(0.75),
+    maxCpuFraction: z.number().min(0.1).max(1).default(0.8),
     /**
      * Upper bound on allowed memory usage before new agent work waits.
-     * Expressed as a fraction of total system memory (1.0 = 100% of RAM).
+     * Expressed as a fraction of total system memory (1.0 = 100%). 0.8 = 80% recommended for parallel.
      */
-    maxMemoryFraction: z.number().min(0.5).max(1).default(0.9),
+    maxMemoryFraction: z.number().min(0.5).max(1).default(0.8),
+    /**
+     * Upper bound on GPU utilization (0–1) when nvidia-smi is available. 0.8 = 80% recommended for parallel.
+     */
+    maxGpuFraction: z.number().min(0.1).max(1).optional(),
     verbose: z.boolean().default(false),
     logLevel: z.enum(['debug', 'info', 'warn', 'error']).default('info'),
     workspaceRoot: z.string().default(process.cwd()),
@@ -87,6 +91,9 @@ function readPlanningOverrides(workspaceRoot) {
         if (typeof parsed.maxMemoryFraction === 'number') {
             overrides.maxMemoryFraction = parsed.maxMemoryFraction;
         }
+        if (typeof parsed.maxGpuFraction === 'number') {
+            overrides.maxGpuFraction = parsed.maxGpuFraction;
+        }
         return overrides;
     }
     catch {

package/dist/daemon.js

@@ -169,6 +169,12 @@ export async function runDaemon(config, logger) {
                         status: 'crashed',
                         error: `Heartbeat timeout (>${heartbeatTimeoutMs / 1000}s)`,
                     });
+                    try {
+                        await sendSms(`GSD goal crashed (heartbeat timeout).\nGoal: ${crashed.goalTitle}`);
+                    }
+                    catch (e) {
+                        logger.debug({ err: e }, 'SMS (goal crashed) skipped or failed');
+                    }
                 }
             }
             catch {
@@ -178,6 +184,12 @@ export async function runDaemon(config, logger) {
                     status: 'crashed',
                     error: 'Heartbeat timeout (missing)',
                 });
+                try {
+                    await sendSms(`GSD goal crashed (heartbeat timeout).\nGoal: ${crashed.goalTitle}`);
+                }
+                catch (e) {
+                    logger.debug({ err: e }, 'SMS (goal crashed) skipped or failed');
+                }
             }
         }
         resumeFrom = await computeResumePointer({
@@ -327,6 +339,12 @@ export async function runDaemon(config, logger) {
                 break;
             }
             logger.info({ goal: goal.title }, `Processing goal: ${goal.title}`);
+            try {
+                await sendSms(`GSD goal started.\nGoal: ${goal.title}`);
+            }
+            catch (e) {
+                logger.debug({ err: e }, 'SMS (goal started) skipped or failed');
+            }
             const isFirst = completedCount === 1 && resumeFrom !== null;
             await workspaceMutex.run(() => runOneGoal(goal, isFirst ? resumeFrom : null));
             running.delete(goal.title);

package/dist/orchestrator.js

@@ -102,6 +102,7 @@ export async function orchestrateGoal(options) {
         await waitForHeadroom({
             maxCpuFraction: config.maxCpuFraction,
             maxMemoryFraction: config.maxMemoryFraction,
+            maxGpuFraction: config.maxGpuFraction,
             logger,
         });
     }

package/dist/resource-governor.d.ts

@@ -16,18 +16,28 @@ export interface LoadInfo {
     memoryFraction: number;
     totalMemBytes: number;
     freeMemBytes: number;
+    /**
+     * Best-effort GPU utilization fraction (0–1). Only set when nvidia-smi is
+     * available and returns utilization; otherwise undefined.
+     */
+    gpuFraction?: number;
 }
 export interface WaitForHeadroomOptions {
     /**
      * Maximum allowed CPU fraction before new agent work is allowed to start.
-     * 1.0 means 100% of all logical CPUs; 0.75 (default) means ~75% of total.
+     * 1.0 means 100% of all logical CPUs; 0.8 recommended for parallel work.
      */
     maxCpuFraction: number;
     /**
      * Maximum allowed memory fraction before new agent work is allowed to start.
-     * 1.0 means 100% of total RAM; 0.9 (default) means ~90%.
+     * 1.0 means 100% of total RAM; 0.8 recommended for parallel work.
      */
     maxMemoryFraction?: number;
+    /**
+     * Maximum allowed GPU utilization fraction (0–1). Only checked when
+     * nvidia-smi is available. 0.8 recommended for parallel work.
+     */
+    maxGpuFraction?: number;
     /**
      * Minimum delay between load checks while waiting for headroom.
      * Defaults to 2s to avoid busy-waiting.
@@ -47,8 +57,24 @@ export interface WaitForHeadroomOptions {
         warn: (obj: unknown, msg?: string) => void;
     };
 }
-export declare function currentLoadInfo(maxCpuFraction?: number, maxMemoryFraction?: number): LoadInfo & {
+/**
+ * Best-effort GPU utilization fraction (0–1) via nvidia-smi. Returns undefined
+ * if nvidia-smi is not available or parsing fails.
+ */
+export declare function getGpuFraction(): Promise<number | undefined>;
+export declare function currentLoadInfo(maxCpuFraction?: number, maxMemoryFraction?: number, gpuFraction?: number): LoadInfo & {
     maxCpuFraction?: number;
     maxMemoryFraction?: number;
+    maxGpuFraction?: number;
 };
+/** Like currentLoadInfo but async; fetches GPU utilization when maxGpuFraction is set. */
+export declare function currentLoadInfoAsync(options: {
+    maxCpuFraction?: number;
+    maxMemoryFraction?: number;
+    maxGpuFraction?: number;
+}): Promise<LoadInfo & {
+    maxCpuFraction?: number;
+    maxMemoryFraction?: number;
+    maxGpuFraction?: number;
+}>;
 export declare function waitForHeadroom(options: WaitForHeadroomOptions): Promise<void>;

package/dist/resource-governor.js

@@ -1,5 +1,28 @@
 import os from 'node:os';
-export function currentLoadInfo(maxCpuFraction, maxMemoryFraction) {
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileP = promisify(execFile);
+/**
+ * Best-effort GPU utilization fraction (0–1) via nvidia-smi. Returns undefined
+ * if nvidia-smi is not available or parsing fails.
+ */
+export async function getGpuFraction() {
+    try {
+        const { stdout } = await execFileP('nvidia-smi', ['--query-gpu=utilization.gpu', '--format=csv,noheader,nounits'], {
+            timeout: 5000,
+            encoding: 'utf-8',
+        });
+        const line = stdout.trim().split('\n')[0];
+        const pct = line ? parseInt(line.trim(), 10) : NaN;
+        if (Number.isFinite(pct) && pct >= 0 && pct <= 100)
+            return pct / 100;
+    }
+    catch {
+        // nvidia-smi not installed or failed
+    }
+    return undefined;
+}
+export function currentLoadInfo(maxCpuFraction, maxMemoryFraction, gpuFraction) {
     const [load1, load5, load15] = os.loadavg();
     const cpuCount = Math.max(os.cpus()?.length ?? 1, 1);
     const cpuFraction = cpuCount > 0 ? load1 / cpuCount : 0;
@@ -15,34 +38,48 @@ export function currentLoadInfo(maxCpuFraction, maxMemoryFraction) {
         memoryFraction,
         totalMemBytes,
         freeMemBytes,
+        gpuFraction,
         maxCpuFraction,
         maxMemoryFraction,
     };
 }
+/** Like currentLoadInfo but async; fetches GPU utilization when maxGpuFraction is set. */
+export async function currentLoadInfoAsync(options) {
+    const gpuFraction = options.maxGpuFraction != null ? await getGpuFraction() : undefined;
+    const info = currentLoadInfo(options.maxCpuFraction, options.maxMemoryFraction, gpuFraction);
+    return { ...info, maxGpuFraction: options.maxGpuFraction };
+}
 export async function waitForHeadroom(options) {
-    const { maxCpuFraction, maxMemoryFraction, pollIntervalMs = 2000, maxWaitMs = 120_000, logger, } = options;
+    const { maxCpuFraction, maxMemoryFraction, maxGpuFraction, pollIntervalMs = 2000, maxWaitMs = 120_000, logger, } = options;
     // Treat thresholds >= 1 as "no gating" for that resource to keep tests
     // and opt-out configurations fast.
     const validCpu = maxCpuFraction !== undefined && maxCpuFraction > 0 && maxCpuFraction < 1;
     const validMem = maxMemoryFraction !== undefined && maxMemoryFraction > 0 && maxMemoryFraction < 1;
-    if (!validCpu && !validMem) {
-        // Misconfiguration — do not block orchestration, just log once and return.
-        logger?.warn({ maxCpuFraction, maxMemoryFraction }, 'resource-governor: invalid thresholds, skipping headroom check');
+    const validGpu = maxGpuFraction !== undefined && maxGpuFraction > 0 && maxGpuFraction < 1;
+    if (!validCpu && !validMem && !validGpu) {
+        logger?.warn({ maxCpuFraction, maxMemoryFraction, maxGpuFraction }, 'resource-governor: invalid thresholds, skipping headroom check');
         return;
     }
     const start = Date.now();
-    // First, allow a cheap fast-path so we don't sleep when there's plenty of headroom.
-    let info = currentLoadInfo(maxCpuFraction, maxMemoryFraction);
+    async function getInfo() {
+        const gpuFraction = validGpu ? await getGpuFraction() : undefined;
+        const info = currentLoadInfo(maxCpuFraction, maxMemoryFraction, gpuFraction);
+        return { ...info, maxGpuFraction };
+    }
+    let info = await getInfo();
     const withinCpu = !validCpu || info.cpuFraction <= maxCpuFraction;
     const withinMem = !validMem || info.memoryFraction <= maxMemoryFraction;
-    if (withinCpu && withinMem) {
-        logger?.debug({ load: info }, 'resource-governor: sufficient CPU headroom, proceeding immediately');
+    const withinGpu = !validGpu ||
+        info.gpuFraction == null ||
+        info.gpuFraction <= maxGpuFraction;
+    if (withinCpu && withinMem && withinGpu) {
+        logger?.debug({ load: info }, 'resource-governor: sufficient headroom, proceeding immediately');
         return;
     }
     logger?.warn({ load: info }, 'resource-governor: high system load detected, waiting for headroom');
-    // Slow-path: periodically poll until below threshold or timeout expires.
     while ((!validCpu || info.cpuFraction > maxCpuFraction) ||
-        (!validMem || info.memoryFraction > maxMemoryFraction)) {
+        (!validMem || info.memoryFraction > maxMemoryFraction) ||
+        (validGpu && info.gpuFraction != null && info.gpuFraction > maxGpuFraction)) {
         const elapsed = Date.now() - start;
         if (elapsed >= maxWaitMs) {
             logger?.warn({ load: info, elapsedMs: elapsed, maxWaitMs }, 'resource-governor: max wait exceeded, proceeding despite high load');
@@ -51,7 +88,7 @@ export async function waitForHeadroom(options) {
         const remainingMs = maxWaitMs - elapsed;
         const delayMs = Math.min(pollIntervalMs, remainingMs);
         await new Promise((resolve) => setTimeout(resolve, delayMs));
-        info = currentLoadInfo(maxCpuFraction, maxMemoryFraction);
+        info = await getInfo();
     }
-    logger?.debug({ load: info, waitedMs: Date.now() - start }, 'resource-governor: CPU headroom restored, resuming work');
+    logger?.debug({ load: info, waitedMs: Date.now() - start }, 'resource-governor: headroom restored, resuming work');
 }

package/dist/status-server.d.ts

@@ -72,6 +72,7 @@ export interface DashboardStatusPayload {
     systemLoad?: import('./resource-governor.js').LoadInfo & {
         maxCpuFraction?: number;
         maxMemoryFraction?: number;
+        maxGpuFraction?: number;
     };
 }
 /** Optional webhook: add goals/todos via API or Twilio inbound. */

package/dist/status-server.js

@@ -12,7 +12,7 @@ function escapeTwiML(s) {
 import { readStateMd } from './state-parser.js';
 import { readSessionLog } from './session-log.js';
 import { getRecentCommits } from './git.js';
-import { currentLoadInfo } from './resource-governor.js';
+import { currentLoadInfo, currentLoadInfoAsync } from './resource-governor.js';
 const DEFAULT_PLANNING_CONFIG = {
     mode: 'interactive',
     depth: 'standard',
@@ -341,11 +341,29 @@ export function createStatusServer(port, getStatus, options) {
     /** Dashboard API: rich payload. */
     app.get('/api/status', async (_req, res) => {
         const legacy = getStatus();
+        let systemLoad = currentLoadInfo();
+        if (options?.planningConfigPath) {
+            try {
+                const raw = await readFile(options.planningConfigPath, 'utf-8');
+                const planning = JSON.parse(raw);
+                const maxCpu = typeof planning.maxCpuFraction === 'number' ? planning.maxCpuFraction : 0.8;
+                const maxMem = typeof planning.maxMemoryFraction === 'number' ? planning.maxMemoryFraction : 0.8;
+                const maxGpu = typeof planning.maxGpuFraction === 'number' ? planning.maxGpuFraction : undefined;
+                systemLoad = await currentLoadInfoAsync({
+                    maxCpuFraction: maxCpu,
+                    maxMemoryFraction: maxMem,
+                    maxGpuFraction: maxGpu,
+                });
+            }
+            catch {
+                // keep sync load info
+            }
+        }
         const payload = {
             ...legacy,
             tokens: {},
             cost: {},
-            systemLoad: currentLoadInfo(),
+            systemLoad,
         };
         if (options) {
             const [stateSnapshot, sessionLogEntries, gitFeed] = await Promise.all([

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-unsupervised",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Autonomous orchestrator for Cursor agent + GSD framework",
   "type": "module",
   "main": "dist/cli.js",
@@ -28,7 +28,8 @@
     "start": "node dist/cli.js",
     "dev": "tsc --watch",
     "test": "vitest run --reporter verbose",
-    "test:integration": "vitest run tests/"
+    "test:integration": "vitest run tests/",
+    "test:sms": "node dist/cli.js test-sms"
   },
   "engines": {
     "node": ">=18"