declare-cc 0.4.8 → 0.5.2

package/bin/install.js

@@ -1636,11 +1636,13 @@ function install(isGlobal, runtime = 'claude') {
 function finishInstall(settingsPath, settings, statuslineCommand, shouldInstallStatusline, runtime = 'claude', isGlobal = true) {
   const isOpencode = runtime === 'opencode';
 
-  if (shouldInstallStatusline && !isOpencode) {
-    settings.statusLine = {
-      type: 'command',
-      command: statuslineCommand
-    };
+  // Statusline is a global UI element — only configure it for global installs.
+  // Local installs must not write statusLine: it would point to a project-specific
+  // path that breaks when the project moves or is deleted.
+  // Users who only do local installs should run `npx declare-cc --claude --global`
+  // once to get the statusline, or configure it manually.
+  if (shouldInstallStatusline && !isOpencode && isGlobal) {
+    settings.statusLine = { type: 'command', command: statuslineCommand };
     console.log(`  ${green}✓${reset} Configured statusline`);
   }
 
@@ -1657,9 +1659,12 @@ function finishInstall(settingsPath, settings, statuslineCommand, shouldInstallS
   if (runtime === 'gemini') program = 'Gemini';
 
   const command = isOpencode ? '/declare-help' : '/declare:help';
+  const statuslineNote = (!isGlobal && !isOpencode)
+    ? `\n  ${yellow}Tip:${reset} For the context-window statusline, run once globally:\n  ${dim}npx declare-cc --claude --global${reset}\n`
+    : '';
   console.log(`
   ${green}Done!${reset} Launch ${program} and run ${cyan}${command}${reset}.
-
+${statuslineNote}
   ${cyan}Docs & source:${reset} https://github.com/decocms/declare-cc
 `);
 }

package/dist/declare-tools.cjs

@@ -1329,7 +1329,7 @@ var require_help = __commonJS({
             usage: "/declare:help"
           }
         ],
-        version: "0.4.7"
+        version: "0.5.1"
       };
     }
     module2.exports = { runHelp: runHelp2 };
@@ -2987,6 +2987,13 @@ var require_sync_status = __commonJS({
             actionResults.push({ id: action.id, milestone: m.id, changed: false, reason: "already DONE" });
             continue;
           }
+          const summaryPath = join(folderPath, `${action.id}-SUMMARY.md`);
+          if (existsSync(summaryPath)) {
+            planContent = updateActionStatus(planContent, action.id, "DONE");
+            planDirty = true;
+            actionResults.push({ id: action.id, milestone: m.id, changed: true, reason: "SUMMARY.md exists" });
+            continue;
+          }
           if (milestoneAlreadyDone) {
             planContent = updateActionStatus(planContent, action.id, "DONE");
             planDirty = true;

package/dist/public/app.js

@@ -203,24 +203,103 @@ function renderStatusBar() {
 
 // ─── Node element builder ─────────────────────────────────────────────────────
 
+const COMPLETED = new Set(['DONE','KEPT','HONORED']);
+const IN_PROGRESS_STORED = new Set(['ACTIVE']);
+
+/**
+ * Compute derived workflow status for a milestone from its action statuses.
+ * This overrides the stored MILESTONES.md status so the dashboard always
+ * reflects reality even if sync-status hasn't been called.
+ *
+ * @param {{ id: string, status: string, hasPlan: boolean }} milestone
+ * @param {Array<{ id: string, status: string, causes: string[] }>} allActions
+ * @returns {{ displayStatus: string, doneCount: number, totalCount: number }}
+ */
+function deriveMilestoneStatus(milestone, allActions) {
+  // Authoritative integrity/terminal states — always trust these
+  if (['KEPT','HONORED','BROKEN','RENEGOTIATED'].includes(milestone.status)) {
+    const myActions = allActions.filter(a => (a.causes||[]).includes(milestone.id));
+    return { displayStatus: milestone.status, doneCount: myActions.filter(a=>COMPLETED.has(a.status)).length, totalCount: myActions.length };
+  }
+
+  const myActions = allActions.filter(a => (a.causes||[]).includes(milestone.id));
+  const doneCount  = myActions.filter(a => COMPLETED.has(a.status)).length;
+  const totalCount = myActions.length;
+
+  let displayStatus;
+  if (totalCount === 0) {
+    displayStatus = milestone.hasPlan ? 'PLANNED' : 'PENDING';
+  } else if (doneCount === totalCount) {
+    displayStatus = 'DONE';
+  } else if (doneCount > 0) {
+    displayStatus = 'EXECUTING';
+  } else {
+    displayStatus = 'PLANNED';
+  }
+
+  return { displayStatus, doneCount, totalCount };
+}
+
+/**
+ * Compute derived workflow status for a declaration from its milestone statuses.
+ * @param {{ id: string, status: string, milestones: string[] }} declaration
+ * @param {Array<{ id: string, displayStatus: string }>} enrichedMilestones
+ * @returns {string}
+ */
+function deriveDeclarationStatus(declaration, enrichedMilestones) {
+  if (['KEPT','HONORED','BROKEN','RENEGOTIATED'].includes(declaration.status)) return declaration.status;
+
+  const myMilestones = enrichedMilestones.filter(m => (declaration.milestones||[]).includes(m.id));
+  if (myMilestones.length === 0) return 'PENDING';
+
+  const doneCount     = myMilestones.filter(m => COMPLETED.has(m.displayStatus)).length;
+  const executingCount = myMilestones.filter(m => m.displayStatus === 'EXECUTING').length;
+  const plannedCount  = myMilestones.filter(m => m.displayStatus === 'PLANNED').length;
+
+  if (doneCount === myMilestones.length) return 'DONE';
+  if (executingCount > 0 || doneCount > 0) return 'EXECUTING';
+  if (plannedCount > 0) return 'PLANNED';
+  return 'PENDING';
+}
+
 /**
  * Build a node DOM element.
- * @param {{ id: string, title?: string, statement?: string, status?: string }} item
+ * @param {object} item
  * @param {'declaration'|'milestone'|'action'} type
+ * @param {{ displayStatus?: string, doneCount?: number, totalCount?: number }} [derived]
  * @returns {HTMLElement}
  */
-function buildNodeEl(item, type) {
+function buildNodeEl(item, type, derived = {}) {
+  const displayStatus = derived.displayStatus || item.status || 'PENDING';
   const el = document.createElement('div');
-  el.className = `node node-${type} status-${statusClass(item.status || 'pending')}`;
-  el.dataset.nodeId = item.id;
+  el.className = `node node-${type} status-${statusClass(displayStatus)}`;
+  el.dataset.nodeId   = item.id;
   el.dataset.nodeType = type;
 
   const title = item.title || item.statement || item.id;
 
+  // Progress bar for milestones with actions
+  let progressHtml = '';
+  if (type === 'milestone' && derived.totalCount > 0) {
+    const pct = Math.round((derived.doneCount / derived.totalCount) * 100);
+    const countLabel = `${derived.doneCount}/${derived.totalCount}`;
+    progressHtml = `
+      <div class="node-progress" title="${countLabel} actions done">
+        <div class="node-progress-fill" style="width:${pct}%"></div>
+      </div>`;
+  }
+
+  // Badge label — show progress count for executing milestones
+  let badgeLabel = displayStatus;
+  if (type === 'milestone' && displayStatus === 'EXECUTING' && derived.totalCount > 0) {
+    badgeLabel = `${derived.doneCount}/${derived.totalCount} DONE`;
+  }
+
   el.innerHTML = `
     <div class="node-id">${item.id}</div>
     <div class="node-title">${truncate(title, 55)}</div>
-    <span class="status-badge">${item.status || 'PENDING'}</span>
+    <span class="status-badge">${badgeLabel}</span>
+    ${progressHtml}
   `;
 
   el.addEventListener('click', () => selectNode(item.id, type));
@@ -234,22 +313,37 @@ function renderGraph() {
 
   const { declarations, milestones, actions } = graphData;
 
+  // ── Compute derived statuses from action data (always reflects reality) ──────
+  // Milestones
+  const enrichedMilestones = (milestones || []).map(m => ({
+    ...m,
+    ...deriveMilestoneStatus(m, actions || []),
+  }));
+
+  // Declarations
+  const enrichedDeclarations = (declarations || []).map(d => ({
+    ...d,
+    displayStatus: deriveDeclarationStatus(d, enrichedMilestones),
+  }));
+
   // Clear containers
   $nodesDecls.innerHTML = '';
   $nodesMiles.innerHTML = '';
   $nodesActs.innerHTML  = '';
 
-  // Render declarations
-  (declarations || []).forEach(d => {
-    $nodesDecls.appendChild(buildNodeEl(d, 'declaration'));
+  // Render
+  enrichedDeclarations.forEach(d => {
+    $nodesDecls.appendChild(buildNodeEl(d, 'declaration', { displayStatus: d.displayStatus }));
   });
 
-  // Render milestones
-  (milestones || []).forEach(m => {
-    $nodesMiles.appendChild(buildNodeEl(m, 'milestone'));
+  enrichedMilestones.forEach(m => {
+    $nodesMiles.appendChild(buildNodeEl(m, 'milestone', {
+      displayStatus: m.displayStatus,
+      doneCount:     m.doneCount,
+      totalCount:    m.totalCount,
+    }));
   });
 
-  // Render actions
   (actions || []).forEach(a => {
     $nodesActs.appendChild(buildNodeEl(a, 'action'));
   });
@@ -1230,7 +1324,13 @@ const COMPLETED_STATES = new Set(['DONE', 'KEPT', 'HONORED']);
 function checkProjectComplete(graph) {
   if (confettiFired) return;
   if (!graph || !graph.declarations || graph.declarations.length === 0) return;
-  const allDone = graph.declarations.every(d => COMPLETED_STATES.has(d.status));
+  // Use derived statuses (computed from actions) not stored MILESTONES.md status
+  const enriched = (graph.milestones || []).map(m => ({
+    ...m, ...deriveMilestoneStatus(m, graph.actions || []),
+  }));
+  const allDone = graph.declarations.every(d =>
+    COMPLETED_STATES.has(deriveDeclarationStatus(d, enriched))
+  );
   if (!allDone) return;
   confettiFired = true;
   fireConfetti();

package/dist/public/index.html

@@ -41,6 +41,15 @@
       --act-done-bg: #08180f;
       --act-done-border: #123428;
 
+      /* workflow progress tones */
+      --planned-color:   #5ba3ff;
+      --planned-bg:      #091828;
+      --planned-border:  #12305a;
+
+      --executing-color: #fbbf24;
+      --executing-bg:    #1a1200;
+      --executing-border:#3d2c00;
+
       --broken-color: #ff4d6d;
       --broken-bg: #2a0a10;
       --broken-border: #5a1520;
@@ -264,6 +273,41 @@
       opacity: 0.82;
     }
 
+    /* Workflow progress states — computed from action data, not MILESTONES.md */
+    .node.status-planned {
+      background: var(--planned-bg);
+      border-color: var(--planned-border);
+      color: var(--planned-color);
+      opacity: 0.9;
+    }
+    .node.status-executing {
+      background: var(--executing-bg);
+      border-color: var(--executing-border);
+      color: var(--executing-color);
+      box-shadow: 0 0 0 1px var(--executing-border), 0 0 12px rgba(251,191,36,0.15);
+    }
+    .node.status-planned .node-title  { color: var(--planned-color); }
+    .node.status-executing .node-title { color: var(--executing-color); }
+
+    /* Progress bar inside milestone node */
+    .node-progress {
+      margin-top: 7px;
+      height: 3px;
+      background: rgba(255,255,255,0.08);
+      border-radius: 2px;
+      overflow: hidden;
+    }
+    .node-progress-fill {
+      height: 100%;
+      border-radius: 2px;
+      transition: width 0.4s ease;
+    }
+    .status-executing .node-progress-fill { background: var(--executing-color); }
+    .status-planned   .node-progress-fill { background: var(--planned-color); opacity:0.3; }
+    .status-done      .node-progress-fill,
+    .status-kept      .node-progress-fill,
+    .status-honored   .node-progress-fill { background: var(--act-done-color); }
+
     .node.status-broken {
       background: var(--broken-bg);
       border-color: var(--broken-border);

package/hooks/declare-activity.js

@@ -0,0 +1,106 @@
+#!/usr/bin/env node
+// Declare activity hook — PreToolUse + PostToolUse
+// Writes interesting tool events to .planning/activity.jsonl
+// Server watches .planning/ via fs.watch and pushes SSE events to dashboard.
+//
+// Installed for PreToolUse and PostToolUse hook events.
+// Runs fast: read stdin → decide → append one line → exit.
+
+'use strict';
+
+const fs   = require('fs');
+const path = require('path');
+const os   = require('os');
+
+const cwd          = process.cwd();
+const planningDir  = path.join(cwd, '.planning');
+const activityFile = path.join(planningDir, 'activity.jsonl');
+
+// Only write if .planning/ exists (i.e. this is a Declare project)
+if (!fs.existsSync(planningDir)) process.exit(0);
+
+let raw = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', c => raw += c);
+process.stdin.on('end', () => {
+  try {
+    const data = JSON.parse(raw);
+    const event = buildEvent(data);
+    if (!event) process.exit(0);
+
+    // Ensure file exists
+    if (!fs.existsSync(activityFile)) fs.writeFileSync(activityFile, '');
+
+    // Append event + trim to last 200 lines
+    const line = JSON.stringify(event) + '\n';
+    fs.appendFileSync(activityFile, line);
+
+    // Trim to last 200 lines to avoid unbounded growth
+    const content = fs.readFileSync(activityFile, 'utf8');
+    const lines = content.split('\n').filter(Boolean);
+    if (lines.length > 200) {
+      fs.writeFileSync(activityFile, lines.slice(-200).join('\n') + '\n');
+    }
+  } catch (_) {
+    // Silent fail — never block Claude
+  }
+  process.exit(0);
+});
+
+/**
+ * Build an activity event from a hook payload, or return null to skip.
+ * @param {any} data
+ * @returns {object|null}
+ */
+function buildEvent(data) {
+  const tool      = data.tool_name || '';
+  const input     = data.tool_input || {};
+  const response  = data.tool_response;
+  const hookEvent = data.hook_event_name || ''; // PreToolUse or PostToolUse
+  const ts        = Date.now();
+  const phase     = hookEvent === 'PostToolUse' ? 'done' : 'start';
+
+  // Task spawns — most important for agent visibility
+  if (tool === 'Task') {
+    return {
+      ts, phase, tool: 'Task',
+      desc:  input.description || '',
+      agent: input.subagent_type || '',
+      // truncate prompt to avoid massive payloads
+      prompt: (input.prompt || '').slice(0, 200),
+      bg: hookEvent === 'PostToolUse',
+    };
+  }
+
+  // Bash commands that involve declare-tools (execution steps)
+  if (tool === 'Bash') {
+    const cmd = input.command || '';
+    if (cmd.includes('declare-tools') || cmd.includes('/declare:')) {
+      return { ts, phase, tool: 'Bash', cmd: cmd.slice(0, 200) };
+    }
+    return null; // skip noisy general bash
+  }
+
+  // Write tool — track planning file changes + auto-sync on SUMMARY.md writes
+  if (tool === 'Write' && hookEvent === 'PostToolUse') {
+    const fp = input.file_path || '';
+    if (fp.includes('.planning/')) {
+      // When an executor writes A-XX-SUMMARY.md, auto-run sync-status so
+      // PLAN.md and MILESTONES.md update immediately without manual intervention
+      if (fp.includes('-SUMMARY.md')) {
+        const { execSync } = require('child_process');
+        try {
+          execSync(`node "${path.join(cwd, '.claude', 'declare-tools.cjs')}" sync-status`, {
+            cwd,
+            timeout: 10000,
+            stdio: 'ignore',
+          });
+        } catch (_) { /* silent — never block Claude */ }
+      }
+      return { ts, phase: 'done', tool: 'Write', file: fp.replace(cwd, '.') };
+    }
+    return null;
+  }
+
+  return null;
+}

package/hooks/declare-check-update.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+// Check for Declare updates in background, write result to cache
+// Called by SessionStart hook - runs once per session
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawn } = require('child_process');
+
+const homeDir = os.homedir();
+const cwd = process.cwd();
+const cacheDir = path.join(homeDir, '.claude', 'cache');
+const cacheFile = path.join(cacheDir, 'declare-update-check.json');
+
+// VERSION file locations (check project first, then global)
+const projectVersionFile = path.join(cwd, '.claude', 'declare', 'VERSION');
+const globalVersionFile = path.join(homeDir, '.claude', 'declare', 'VERSION');
+
+// Ensure cache directory exists
+if (!fs.existsSync(cacheDir)) {
+  fs.mkdirSync(cacheDir, { recursive: true });
+}
+
+// Run check in background (spawn background process, windowsHide prevents console flash)
+const child = spawn(process.execPath, ['-e', `
+  const fs = require('fs');
+  const { execSync } = require('child_process');
+
+  const cacheFile = ${JSON.stringify(cacheFile)};
+  const projectVersionFile = ${JSON.stringify(projectVersionFile)};
+  const globalVersionFile = ${JSON.stringify(globalVersionFile)};
+
+  // Check project directory first (local install), then global
+  let installed = '0.0.0';
+  try {
+    if (fs.existsSync(projectVersionFile)) {
+      installed = fs.readFileSync(projectVersionFile, 'utf8').trim();
+    } else if (fs.existsSync(globalVersionFile)) {
+      installed = fs.readFileSync(globalVersionFile, 'utf8').trim();
+    }
+  } catch (e) {}
+
+  let latest = null;
+  try {
+    latest = execSync('npm view declare-cc version', { encoding: 'utf8', timeout: 10000, windowsHide: true }).trim();
+  } catch (e) {}
+
+  const result = {
+    update_available: latest && installed !== latest,
+    installed,
+    latest: latest || 'unknown',
+    checked: Math.floor(Date.now() / 1000)
+  };
+
+  fs.writeFileSync(cacheFile, JSON.stringify(result));
+`], {
+  stdio: 'ignore',
+  windowsHide: true,
+  detached: true  // Required on Windows for proper process detachment
+});
+
+child.unref();

package/hooks/declare-statusline.js

@@ -0,0 +1,91 @@
+#!/usr/bin/env node
+// Claude Code Statusline - Declare Edition
+// Shows: model | current task | directory | context usage
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+// Read JSON from stdin
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', chunk => input += chunk);
+process.stdin.on('end', () => {
+  try {
+    const data = JSON.parse(input);
+    const model = data.model?.display_name || 'Claude';
+    const dir = data.workspace?.current_dir || process.cwd();
+    const session = data.session_id || '';
+    const remaining = data.context_window?.remaining_percentage;
+
+    // Context window display (shows USED percentage scaled to 80% limit)
+    // Claude Code enforces an 80% context limit, so we scale to show 100% at that point
+    let ctx = '';
+    if (remaining != null) {
+      const rem = Math.round(remaining);
+      const rawUsed = Math.max(0, Math.min(100, 100 - rem));
+      // Scale: 80% real usage = 100% displayed
+      const used = Math.min(100, Math.round((rawUsed / 80) * 100));
+
+      // Build progress bar (10 segments)
+      const filled = Math.floor(used / 10);
+      const bar = '█'.repeat(filled) + '░'.repeat(10 - filled);
+
+      // Color based on scaled usage (thresholds adjusted for new scale)
+      if (used < 63) {        // ~50% real
+        ctx = ` \x1b[32m${bar} ${used}%\x1b[0m`;
+      } else if (used < 81) { // ~65% real
+        ctx = ` \x1b[33m${bar} ${used}%\x1b[0m`;
+      } else if (used < 95) { // ~76% real
+        ctx = ` \x1b[38;5;208m${bar} ${used}%\x1b[0m`;
+      } else {
+        ctx = ` \x1b[5;31m💀 ${bar} ${used}%\x1b[0m`;
+      }
+    }
+
+    // Current task from todos
+    let task = '';
+    const homeDir = os.homedir();
+    const todosDir = path.join(homeDir, '.claude', 'todos');
+    if (session && fs.existsSync(todosDir)) {
+      try {
+        const files = fs.readdirSync(todosDir)
+          .filter(f => f.startsWith(session) && f.includes('-agent-') && f.endsWith('.json'))
+          .map(f => ({ name: f, mtime: fs.statSync(path.join(todosDir, f)).mtime }))
+          .sort((a, b) => b.mtime - a.mtime);
+
+        if (files.length > 0) {
+          try {
+            const todos = JSON.parse(fs.readFileSync(path.join(todosDir, files[0].name), 'utf8'));
+            const inProgress = todos.find(t => t.status === 'in_progress');
+            if (inProgress) task = inProgress.activeForm || '';
+          } catch (e) {}
+        }
+      } catch (e) {
+        // Silently fail on file system errors - don't break statusline
+      }
+    }
+
+    // Declare update available?
+    let gsdUpdate = '';
+    const cacheFile = path.join(homeDir, '.claude', 'cache', 'declare-update-check.json');
+    if (fs.existsSync(cacheFile)) {
+      try {
+        const cache = JSON.parse(fs.readFileSync(cacheFile, 'utf8'));
+        if (cache.update_available) {
+          gsdUpdate = '\x1b[33m⬆ /declare:update\x1b[0m │ ';
+        }
+      } catch (e) {}
+    }
+
+    // Output
+    const dirname = path.basename(dir);
+    if (task) {
+      process.stdout.write(`${gsdUpdate}\x1b[2m${model}\x1b[0m │ \x1b[1m${task}\x1b[0m │ \x1b[2m${dirname}\x1b[0m${ctx}`);
+    } else {
+      process.stdout.write(`${gsdUpdate}\x1b[2m${model}\x1b[0m │ \x1b[2m${dirname}\x1b[0m${ctx}`);
+    }
+  } catch (e) {
+    // Silent fail - don't break statusline on parse errors
+  }
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "declare-cc",
-  "version": "0.4.8",
+  "version": "0.5.2",
   "description": "A future-driven meta-prompting engine for agentic development, rooted in declared futures and causal graph structure.",
   "bin": {
     "declare-cc": "bin/install.js"
@@ -10,6 +10,7 @@
     "commands",
     "agents",
     "dist",
+    "hooks",
     "scripts",
     "workflows",
     "templates"