@tekyzinc/gsd-t 3.29.10 → 4.0.12

package/bin/unattended-watch-format.cjs

@@ -1,178 +0,0 @@
-/**
- * bin/unattended-watch-format.cjs
- *
- * Pure formatter for the unattended watch-tick activity block (M38 ES).
- * Given an array of events (as returned by event-stream.readSinceCursor) and
- * supervisor state, render the human-scannable output per
- * `.gsd-t/contracts/unattended-event-stream-contract.md` §4.
- *
- * Kept separate from the watch command so it can be unit-tested (ES-T3) and
- * so the command itself stays a thin shell wrapper.
- */
-
-"use strict";
-
-function _groupByIter(events) {
-  const groups = new Map();
-  for (const ev of events) {
-    if (!ev || typeof ev !== "object") continue;
-    const iter = Number.isFinite(ev.iter) ? ev.iter : 0;
-    if (!groups.has(iter)) groups.set(iter, []);
-    groups.get(iter).push(ev);
-  }
-  return [...groups.entries()].sort((a, b) => a[0] - b[0]);
-}
-
-function _fmtElapsed(startedAt, now) {
-  if (!startedAt) return "";
-  const t = Date.parse(startedAt);
-  if (!Number.isFinite(t)) return "";
-  const ms = (now || Date.now()) - t;
-  const m = Math.floor(ms / 60000);
-  if (m < 60) return `+${m}m elapsed`;
-  const h = Math.floor(m / 60);
-  return `+${h}h${m % 60}m elapsed`;
-}
-
-function _fmtDuration(s) {
-  if (!Number.isFinite(s) || s < 0) return "";
-  if (s < 60) return `${s}s`;
-  const m = Math.floor(s / 60);
-  return `${m}m ${s % 60}s`;
-}
-
-function _formatIteration(iter, evs) {
-  const taskStart = evs.find((e) => e.type === "task_start");
-  const taskComplete = evs.find((e) => e.type === "task_complete");
-  const fileChanges = evs.filter((e) => e.type === "file_changed");
-  const testResults = evs.filter((e) => e.type === "test_result");
-  const verdicts = evs.filter((e) => e.type === "subagent_verdict");
-  const errors = evs.filter((e) => e.type === "error");
-  const retries = evs.filter((e) => e.type === "retry");
-
-  const lines = [];
-  if (taskStart) {
-    const wave = taskStart.wave ? ` (wave ${taskStart.wave})` : "";
-    const task = taskStart.task || "(unnamed)";
-    lines.push(`  ▶  task: ${task}${wave}`);
-  }
-  if (fileChanges.length > 0) {
-    const paths = fileChanges.map((e) => e.path || "?").filter(Boolean);
-    const shown = paths.slice(0, 5).join(", ");
-    const extra = paths.length > 5 ? ` … and ${paths.length - 5} more` : "";
-    lines.push(`  📝  ${paths.length} file${paths.length === 1 ? "" : "s"} modified (${shown}${extra})`);
-  }
-  for (const tr of testResults) {
-    const suite = tr.suite || "?";
-    const pass = Number.isFinite(tr.pass) ? tr.pass : 0;
-    const total = Number.isFinite(tr.total) ? tr.total : 0;
-    const mark = (tr.fail || 0) > 0 ? "❌" : "✅";
-    lines.push(`  ${mark}  test_result: ${suite} ${pass}/${total} pass`);
-  }
-  for (const v of verdicts) {
-    const agent = v.agent || "?";
-    const verdict = v.verdict || "?";
-    const findings = Number.isFinite(v.findings_count) ? ` (${v.findings_count} findings)` : "";
-    const mark = verdict === "pass" || verdict === "grudging_pass" ? "✅" : "❌";
-    lines.push(`  ${mark}  subagent_verdict: ${agent} ${verdict}${findings}`);
-  }
-  for (const er of errors) {
-    lines.push(`  ❌  error: ${er.error || "(unknown)"}${er.recoverable ? " [recoverable]" : ""}`);
-  }
-  for (const r of retries) {
-    lines.push(`  🔁  retry: attempt ${r.attempt || iter} — ${r.reason || "?"}`);
-  }
-  if (taskComplete) {
-    const dur = _fmtDuration(taskComplete.duration_s);
-    const verdict = taskComplete.verdict || "?";
-    lines.push(`  ⏱  duration: ${dur} · verdict: ${verdict}`);
-  }
-  return lines;
-}
-
-/**
- * Format an activity block for the watch tick.
- *
- * @param {object} args
- * @param {object[]} args.events — events since last cursor (may be empty)
- * @param {object} args.state — supervisor state.json contents
- * @param {number} [args.now] — override for Date.now() (tests)
- * @returns {string}
- */
-function _renderWatchProgressTree(args) {
-  // M39 D2 — best-effort watch-progress tree appended below the formatter
-  // output. Banner preserved verbatim; returns "" on any failure so callers
-  // never see a tree when state is missing/unavailable.
-  try {
-    const wp = require("./watch-progress.js");
-    const stateDir = (args && args.stateDir) || ".gsd-t/.watch-state";
-    const current = args && args.currentAgent ? args.currentAgent : null;
-    const tree = wp.buildTree(stateDir);
-    return wp.renderTree(tree, { currentAgent: current }) || "";
-  } catch (_) {
-    return "";
-  }
-}
-
-function formatWatchTick(args) {
-  const events = Array.isArray(args && args.events) ? args.events : [];
-  const state = (args && args.state) || {};
-  const now = args && Number.isFinite(args.now) ? args.now : Date.now();
-
-  const elapsed = _fmtElapsed(state.startedAt, now);
-  const iter = Number.isFinite(state.iter) ? state.iter : 0;
-  const header = `[unattended supervisor — iter ${iter}${elapsed ? `, ${elapsed}` : ""}]`;
-
-  let body;
-  if (events.length === 0) {
-    body = `${header} (no new activity since last tick)`;
-  } else {
-    const groups = _groupByIter(events);
-    const blocks = [];
-    for (const [groupIter, evs] of groups) {
-      const groupHeader = groups.length > 1 ? `[iter ${groupIter}]` : header;
-      const bodyLines = _formatIteration(groupIter, evs);
-      blocks.push([groupHeader, ...bodyLines].join("\n"));
-    }
-    body = groups.length > 1 ? `${header}\n${blocks.join("\n")}` : blocks[0];
-  }
-
-  // M39 D2 — watch-progress tree below the existing formatter output.
-  // Banner preserved verbatim; tree appended only when caller opts in via
-  // `args.withWatchProgress = true`. Default-off preserves backward
-  // compatibility with existing snapshot-style callers (tests).
-  if (!(args && args.withWatchProgress === true)) return body;
-  const tree = _renderWatchProgressTree({
-    stateDir: args && args.stateDir,
-    currentAgent: args && (args.currentAgent || state.sessionId),
-  });
-  return tree ? `${body}\n${tree}` : body;
-}
-
-/**
- * Terminal-status block when supervisor reached `done`/`failed`/`stopped`/`crashed`.
- * Returns null if status is not terminal.
- */
-function formatTerminalBlock(state) {
-  if (!state || typeof state !== "object") return null;
-  const s = state.status;
-  if (s === "done") {
-    return `🎉  Unattended supervisor COMPLETED the milestone (${state.milestone || "?"}, iter ${state.iter || 0}).`;
-  }
-  if (s === "failed") {
-    return `❌  Unattended supervisor HALTED — status=failed (last exit ${state.lastExit ?? "?"}, iter ${state.iter || 0}).`;
-  }
-  if (s === "stopped") {
-    return `🛑  Unattended supervisor STOPPED by user (iter ${state.iter || 0}).`;
-  }
-  if (s === "crashed") {
-    return `💥  Unattended supervisor CRASHED (iter ${state.iter || 0}).`;
-  }
-  return null;
-}
-
-module.exports = {
-  formatWatchTick,
-  formatTerminalBlock,
-  _internal: { _groupByIter, _formatIteration, _fmtElapsed, _fmtDuration },
-};

package/bin/watch-progress.js

@@ -1,155 +0,0 @@
-#!/usr/bin/env node
-/**
- * bin/watch-progress.js — GSD-T Watch-Progress Tree Builder + Renderer
- *
- * Reads `.gsd-t/.watch-state/*.json` state files written by
- * `scripts/gsd-t-watch-state.js` and reconstructs the agent workflow tree
- * via `parent_agent_id` lineage. Renders a task-list with ✅/🔄/⬜ markers
- * below every `--watch` surface (banner preserved intact).
- *
- * Contract: `.gsd-t/contracts/watch-progress-contract.md` v1.0.0
- * Owner:    D2 (M39 `d2-progress-watch`)
- * Zero external deps.
- */
-
-"use strict";
-
-const fs = require("fs");
-const path = require("path");
-
-const STALE_MS = 24 * 60 * 60 * 1000; // 24h
-
-const MARKERS = {
-  done: "✅",
-  in_progress: "🔄",
-  pending: "⬜",
-  skipped: "➡️",
-  failed: "❌",
-};
-
-function _readAll(stateDir) {
-  if (!stateDir || !fs.existsSync(stateDir)) return [];
-  let entries;
-  try {
-    entries = fs.readdirSync(stateDir);
-  } catch (_) {
-    return [];
-  }
-  const records = [];
-  for (const f of entries) {
-    if (!f.endsWith(".json")) continue;
-    try {
-      const raw = fs.readFileSync(path.join(stateDir, f), "utf8");
-      const rec = JSON.parse(raw);
-      if (rec && typeof rec === "object" && typeof rec.agent_id === "string") {
-        records.push(rec);
-      }
-    } catch (_) { /* skip malformed */ }
-  }
-  return records;
-}
-
-function _isStale(record, now) {
-  if (!record.completed_at) return false;
-  const t = Date.parse(record.completed_at);
-  if (!Number.isFinite(t)) return false;
-  return (now - t) > STALE_MS;
-}
-
-function buildTree(stateDir, options) {
-  const now = options && Number.isFinite(options.now) ? options.now : Date.now();
-  const records = _readAll(stateDir).filter((r) => !_isStale(r, now));
-  const index = new Map();
-  for (const r of records) index.set(r.agent_id, { record: r, children: [] });
-  const roots = [];
-  const orphans = [];
-  for (const r of records) {
-    const node = index.get(r.agent_id);
-    const parentId = r.parent_agent_id;
-    if (parentId === null || parentId === undefined) {
-      roots.push(node);
-    } else if (index.has(parentId)) {
-      index.get(parentId).children.push(node);
-    } else {
-      orphans.push(node);
-    }
-  }
-  return { roots, orphans };
-}
-
-function _marker(status) {
-  return MARKERS[status] || MARKERS.pending;
-}
-
-function _countDone(node) {
-  let count = 0;
-  const s = node.record.status;
-  if (s === "done" || s === "skipped") count = 1;
-  for (const c of node.children) count += _countDone(c);
-  return count;
-}
-
-function _flattenIds(node, acc) {
-  acc.push(node.record.agent_id);
-  for (const c of node.children) _flattenIds(c, acc);
-  return acc;
-}
-
-function _containsAgent(node, agentId) {
-  if (!agentId) return false;
-  return _flattenIds(node, []).includes(agentId);
-}
-
-function _pickCurrent(tree) {
-  let pick = null;
-  let latest = -Infinity;
-  const walk = (node) => {
-    const r = node.record;
-    if (r.status === "in_progress" && r.started_at) {
-      const t = Date.parse(r.started_at);
-      if (Number.isFinite(t) && t > latest) { latest = t; pick = r.agent_id; }
-    }
-    for (const c of node.children) walk(c);
-  };
-  for (const root of tree.roots) walk(root);
-  return pick;
-}
-
-function _renderExpanded(node, depth, lines) {
-  const indent = "  ".repeat(depth);
-  const r = node.record;
-  lines.push(`${indent}${_marker(r.status)} ${r.step_label || r.command || r.agent_id}`);
-  for (const c of node.children) _renderExpanded(c, depth + 1, lines);
-}
-
-function _renderCollapsed(node, depth, lines) {
-  const indent = "  ".repeat(depth);
-  const r = node.record;
-  const doneCount = _countDone(node);
-  const label = r.step_label || r.command || r.agent_id;
-  lines.push(`${indent}${_marker(r.status)} ${label} (${doneCount} tasks done)`);
-}
-
-function renderTree(tree, options) {
-  if (!tree || (tree.roots.length === 0 && tree.orphans.length === 0)) return "";
-  const opts = options || {};
-  const currentAgent = opts.currentAgent || _pickCurrent(tree);
-  const lines = [];
-  for (const root of tree.roots) {
-    if (_containsAgent(root, currentAgent)) _renderExpanded(root, 0, lines);
-    else _renderCollapsed(root, 0, lines);
-  }
-  if (tree.orphans.length > 0) {
-    lines.push("⬜ (orphan subtree — parent state missing)");
-    for (const o of tree.orphans) _renderExpanded(o, 1, lines);
-  }
-  return lines.join("\n");
-}
-
-module.exports = { buildTree, renderTree, MARKERS, STALE_MS, _pickCurrent };
-
-if (require.main === module) {
-  const stateDir = process.argv[2] || path.join(".gsd-t", ".watch-state");
-  const out = renderTree(buildTree(stateDir));
-  if (out) process.stdout.write(out + "\n");
-}

package/commands/gsd-t-unattended-stop.md

@@ -1,85 +0,0 @@
-# GSD-T: Unattended Stop — Signal Supervisor to Halt
-
-**Model**: haiku (trivial sentinel toucher — no reasoning needed)
-
-You are signaling the unattended supervisor to halt cleanly between worker iterations by writing the stop sentinel file at `.gsd-t/.unattended/stop`. This is a fire-and-forget command: no PID kill, no wait, no confirmation prompt.
-
-See `unattended-supervisor-contract.md` §10 (Stop Mechanism) for the full handshake.
-
-## Step 1: Check Supervisor State Directory Exists
-
-Run via Bash:
-
-```bash
-if [ ! -d ".gsd-t/.unattended" ]; then
-  echo "No supervisor state directory — nothing to stop."
-  exit 0
-fi
-```
-
-If the directory does not exist, exit 0 (not an error — there is simply nothing to signal).
-
-## Step 2: Check Supervisor PID File Exists
-
-Run via Bash:
-
-```bash
-if [ ! -f ".gsd-t/.unattended/supervisor.pid" ]; then
-  echo "No supervisor running in this project (no PID file at .gsd-t/.unattended/supervisor.pid)."
-  exit 0
-fi
-```
-
-If the PID file is missing, the supervisor has already finalized cleanly. Exit 0 without writing the sentinel.
-
-## Step 3: Read Current Session Snapshot
-
-Run via Bash to grab the session ID and current iteration from `state.json` (best-effort — tolerate missing or partial state):
-
-```bash
-node -e "
-try {
-  const s = JSON.parse(require('fs').readFileSync('.gsd-t/.unattended/state.json', 'utf8'));
-  console.log('SESSION=' + (s.sessionId || 'unknown'));
-  console.log('ITER=' + (s.iter ?? 'unknown'));
-  console.log('STATUS=' + (s.status || 'unknown'));
-} catch (e) {
-  console.log('SESSION=unknown');
-  console.log('ITER=unknown');
-  console.log('STATUS=unknown');
-}
-"
-```
-
-## Step 4: Write the Stop Sentinel
-
-Write `.gsd-t/.unattended/stop` containing the current ISO timestamp as the body (for diagnostics — the supervisor only checks for the file's existence, not its contents):
-
-```bash
-node -e "require('fs').writeFileSync('.gsd-t/.unattended/stop', new Date().toISOString())"
-```
-
-This is race-free, terminal-close-safe, and language-agnostic (per contract §10).
-
-## Step 5: Print Confirmation
-
-Output the confirmation block:
-
-```
-🛑  Stop sentinel written. Supervisor will halt after the current worker finishes (up to ~5 min).
-
-   Session: {SESSION from Step 3}
-   Iter:    {ITER from Step 3}
-   Status:  {STATUS from Step 3}
-
-   The current worker runs to completion. Stop is honored at the next pre-worker checkpoint.
-   The watch loop (if running) will detect status=stopped on its next tick and stop itself.
-   If a watch tick fires before the supervisor processes the sentinel, it may reschedule once
-   more — this is expected. It will catch the terminal status on the following tick.
-```
-
-## Step 6: Return Immediately
-
-Do NOT wait for the supervisor to acknowledge. Do NOT poll state.json. Do NOT call ScheduleWakeup. The supervisor will finalize state.json with `status=stopped` on its next iteration check — that's the watch loop's job to observe, not this command's.
-
-$ARGUMENTS