feat(conductor): write status file + dashboard widget

- Conductor writes .stackmemory/conductor-status.json on each poll cycle
- Dashboard reads status file and renders conductor panel with running
  agents, completion stats, and stale detection
- Add tsconfig.check.json for src-only type checking
- Status file is cleared on conductor stop

Author: StackMemory Bot (CLI)

src/cli/commands/dashboard.ts

@@ -9,7 +9,7 @@ import { SessionManager } from '../../core/session/session-manager.js';
 import { FrameManager } from '../../core/context/index.js';
 import Database from 'better-sqlite3';
 import { join } from 'path';
-import { existsSync } from 'fs';
+import { existsSync, readFileSync } from 'fs';
 import { getModelTokenLimit } from '../../core/models/model-router.js';
 
 /** Frame statistics row */
@@ -216,6 +216,82 @@ export const dashboardCommand = {
       console.log(`${usageBar} ${contextUsage}%`);
       console.log();
 
+      // Conductor Status
+      const conductorStatusPath = join(
+        projectRoot,
+        '.stackmemory',
+        'conductor-status.json'
+      );
+      if (existsSync(conductorStatusPath)) {
+        try {
+          const raw = readFileSync(conductorStatusPath, 'utf-8');
+          const conductorStatus = JSON.parse(raw) as {
+            startedAt: number;
+            updatedAt: number;
+            running: Array<{
+              identifier: string;
+              title: string;
+              status: string;
+              runtime: number;
+            }>;
+            queued: number;
+            completed: number;
+            failed: number;
+            maxConcurrent: number;
+            stopping: boolean;
+          };
+
+          const stale = Date.now() - conductorStatus.updatedAt > 120000;
+          const header = stale
+            ? chalk.gray.bold('⚙ Conductor (stale)')
+            : chalk.yellow.bold('⚙ Conductor');
+
+          console.log(header);
+
+          if (conductorStatus.running.length > 0) {
+            const conductorTable = new Table({
+              head: [
+                chalk.white('Issue'),
+                chalk.white('Status'),
+                chalk.white('Title'),
+                chalk.white('Runtime'),
+              ],
+              style: { head: [], border: [] },
+              colWidths: [12, 14, 36, 10],
+            });
+
+            conductorStatus.running.forEach((r) => {
+              const mins = Math.round(r.runtime / 60000);
+              const statusColor =
+                r.status === 'running'
+                  ? chalk.green
+                  : r.status === 'completed'
+                    ? chalk.cyan
+                    : chalk.red;
+              conductorTable.push([
+                r.identifier,
+                statusColor(r.status),
+                r.title.slice(0, 34),
+                `${mins}m`,
+              ]);
+            });
+
+            console.log(conductorTable.toString());
+          } else {
+            console.log(chalk.gray('  No agents running'));
+          }
+
+          console.log(
+            chalk.gray(
+              `  Completed: ${conductorStatus.completed}  Failed: ${conductorStatus.failed}  Max: ${conductorStatus.maxConcurrent}`
+            )
+          );
+          console.log();
+        } catch {
+          // Ignore corrupt status file
+        }
+      }
+
       db.close();
 
       // Footer

src/cli/commands/orchestrator.ts

@@ -9,7 +9,7 @@
  */
 
 import { spawn, execSync, type ChildProcess } from 'child_process';
-import { existsSync, mkdirSync, rmSync } from 'fs';
+import { existsSync, mkdirSync, rmSync, writeFileSync } from 'fs';
 import { join, dirname } from 'path';
 import { tmpdir } from 'os';
 import { fileURLToPath } from 'url';
@@ -222,6 +222,8 @@ export class Conductor {
       `Orchestrator started — polling every ${this.config.pollIntervalMs / 1000}s, max ${this.config.maxConcurrent} concurrent`
     );
 
+    this.writeStatusFile();
+
     // Register signal handlers
     const shutdown = () => this.stop();
     process.on('SIGINT', shutdown);
@@ -283,6 +285,7 @@ export class Conductor {
 
     this.running.clear();
     this.claimed.clear();
+    this.clearStatusFile();
 
     console.log(
       `Orchestrator stopped. Completed: ${this.completeCount}, Failed: ${this.failCount}`
@@ -310,6 +313,61 @@ export class Conductor {
     };
   }
 
+  // ── Status File ──
+
+  /**
+   * Write current conductor state to .stackmemory/conductor-status.json
+   * for consumption by `stackmemory dashboard` and other tools.
+   */
+  private writeStatusFile(): void {
+    const statusDir = join(this.config.repoRoot, '.stackmemory');
+    if (!existsSync(statusDir)) return;
+
+    const status = {
+      pid: process.pid,
+      startedAt: this.startedAt,
+      updatedAt: Date.now(),
+      running: Array.from(this.running.values()).map((r) => ({
+        identifier: r.issue.identifier,
+        title: r.issue.title,
+        status: r.status,
+        attempt: r.attempt,
+        startedAt: r.startedAt,
+        runtime: Date.now() - r.startedAt,
+      })),
+      queued: Array.from(this.claimed).filter(
+        (id) => !this.running.has(id) && !this.completed.has(id)
+      ).length,
+      completed: this.completeCount,
+      failed: this.failCount,
+      totalAttempts: this.totalAttempts,
+      maxConcurrent: this.config.maxConcurrent,
+      stopping: this.stopping,
+    };
+
+    try {
+      writeFileSync(
+        join(statusDir, 'conductor-status.json'),
+        JSON.stringify(status, null, 2)
+      );
+    } catch {
+      // Non-fatal — status file is best-effort
+    }
+  }
+
+  private clearStatusFile(): void {
+    const statusPath = join(
+      this.config.repoRoot,
+      '.stackmemory',
+      'conductor-status.json'
+    );
+    try {
+      if (existsSync(statusPath)) rmSync(statusPath);
+    } catch {
+      // Non-fatal
+    }
+  }
+
   // ── Polling ──
 
   private async schedulePoll(): Promise<void> {
@@ -325,6 +383,7 @@ export class Conductor {
       } catch (err) {
         logger.error('Poll cycle failed', { error: (err as Error).message });
       }
+      this.writeStatusFile();
     }
   }
 
@@ -525,6 +584,7 @@ export class Conductor {
       console.log(`[${issue.identifier}] Failed: ${(err as Error).message}`);
     } finally {
       this.running.delete(issueId);
+      this.writeStatusFile();
       // Keep claimed so we don't re-dispatch within this session
     }
   }

tsconfig.check.json

@@ -0,0 +1,18 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "declaration": false,
+    "declarationMap": false,
+    "sourceMap": false,
+    "incremental": true,
+    "tsBuildInfoFile": ".tsbuildinfo"
+  },
+  "include": ["src/**/*"],
+  "exclude": [
+    "node_modules",
+    "dist",
+    "**/*.test.ts",
+    "**/__tests__/**"
+  ]
+}