@bvdm/delano 0.2.3 → 0.2.4

package/.delano/viewer/server.js

@@ -12,7 +12,16 @@ const { spawn, spawnSync } = require('node:child_process');
 const repoRoot = path.resolve(process.env.DELANO_VIEWER_ROOT || path.resolve(__dirname, '..', '..'));
 const projectRoot = path.join(repoRoot, '.project');
 const publicRoot = path.join(__dirname, 'public');
-const port = Number(process.env.DELANO_VIEWER_PORT || process.env.PORT || 3977);
+const DEFAULT_PORT = 3977;
+const MAX_PORT = 65535;
+const MAX_PORT_ATTEMPTS = 100;
+const startPort = normalizePort(process.env.DELANO_VIEWER_PORT || process.env.PORT, DEFAULT_PORT);
+
+function normalizePort(value, fallback) {
+  const parsed = Number(value || fallback);
+  if (!Number.isInteger(parsed) || parsed < 1 || parsed > MAX_PORT) return fallback;
+  return parsed;
+}
 
 function isInside(parent, child) {
   const rel = path.relative(parent, child);
@@ -332,6 +341,7 @@ function sendStatic(res, pathname) {
   const ext = path.extname(resolved).toLowerCase();
   const mimeMap = {
     '.js': 'text/javascript',
+    '.jsx': 'text/javascript',
     '.css': 'text/css',
     '.svg': 'image/svg+xml',
     '.png': 'image/png',
@@ -340,7 +350,7 @@ function sendStatic(res, pathname) {
     '.webp': 'image/webp',
     '.ico': 'image/x-icon',
   };
-  const isText = ext === '.js' || ext === '.css' || ext === '.svg' || ext === '' || ext === '.html';
+  const isText = ext === '.js' || ext === '.jsx' || ext === '.css' || ext === '.svg' || ext === '' || ext === '.html';
   const type = mimeMap[ext] || 'text/html';
   const headers = isText ? { 'content-type': `${type}; charset=utf-8` } : { 'content-type': type };
   res.writeHead(200, headers);
@@ -384,6 +394,37 @@ const server = http.createServer((req, res) => {
   }
 });
 
-server.listen(port, '127.0.0.1', () => {
-  console.log(`Delano read-only viewer: http://127.0.0.1:${port}`);
-});
+function listenWithPortFallback(server, firstPort, host = '127.0.0.1') {
+  let port = firstPort;
+  let attempts = 0;
+
+  const listen = () => {
+    server.once('error', onError);
+    server.listen(port, host);
+  };
+
+  const onError = (error) => {
+    if (error.code === 'EADDRINUSE' && port < MAX_PORT && attempts < MAX_PORT_ATTEMPTS) {
+      attempts += 1;
+      port += 1;
+      listen();
+      return;
+    }
+
+    console.error(`Failed to start Delano viewer on ${host}:${port}: ${error.message}`);
+    process.exitCode = 1;
+  };
+
+  const onListening = () => {
+    server.removeListener('error', onError);
+    const address = server.address();
+    const actualPort = typeof address === 'object' && address ? address.port : port;
+    const skipped = actualPort !== firstPort ? ` (${firstPort} was unavailable)` : '';
+    console.log(`Delano read-only viewer: http://${host}:${actualPort}${skipped}`);
+  };
+
+  server.on('listening', onListening);
+  listen();
+}
+
+listenWithPortFallback(server, startPort);

package/README.md

@@ -15,7 +15,7 @@ The npm package is intentionally thin. It distributes the approved runtime paylo
 ## Delano CLI
 
 - Package: `@bvdm/delano`
-- Current package version: `0.2.3`
+- Current package version: `0.2.4`
 - Binary: `delano`
 - Commands: `onboarding`, `install`, `viewer`, `init`, `validate`, `status`, `next`
 - Primary goal: bootstrap a repo safely, expose local delivery state clearly, and keep runtime gates verifiable
@@ -111,6 +111,7 @@ npx -y @bvdm/delano@latest onboarding --approve-agents-analysis
 npx -y @bvdm/delano@latest viewer
 npx -y @bvdm/delano@latest validate
 npx -y @bvdm/delano@latest status
+npx -y @bvdm/delano@latest status --open --brief
 npx -y @bvdm/delano@latest next -- --all
 ```
 
@@ -121,6 +122,7 @@ delano onboarding
 delano viewer
 delano validate
 delano status
+delano status --open --brief
 delano next -- --all
 delano init <slug> "<Project Name>" [owner] [lead]
 ```
@@ -130,6 +132,7 @@ The wrapper commands call the existing PM scripts under `.agents/scripts/pm/`. Y
 ```bash
 bash .agents/scripts/pm/validate.sh
 bash .agents/scripts/pm/status.sh
+bash .agents/scripts/pm/status.sh --open --brief
 bash .agents/scripts/pm/next.sh --all
 ```
 
@@ -160,6 +163,28 @@ The CLI does not bundle its own shell or Python runtime.
 
 The base install payload intentionally excludes top-level adapter entry docs such as `AGENTS.md`, `CLAUDE.md`, `CODEX.md`, `OPENCODE.md`, and `PI.md`. Those remain opt-in only.
 The base install payload includes `.delano/`, including the read-only viewer UI.
+The base install payload also includes `.codex/hooks.json`, a Codex `SessionStart` hook config that injects compact open-project context when Codex hooks are enabled. If a target repo already has `.codex/hooks.json`, `delano install` merges the Delano hook into the existing JSON instead of replacing it. Invalid or non-file hook configs are skipped without blocking the rest of the install.
+
+Codex hook activation is intentionally manual:
+
+1. Enable hooks for a session with `codex --enable hooks`, or persist the feature in `~/.codex/config.toml`:
+
+   ```toml
+   [features]
+   hooks = true
+   ```
+
+2. Start Codex in the repository and approve the project trust prompt for the repo-local `.codex/` layer. Codex records trusted projects in `~/.codex/config.toml`, for example:
+
+   ```toml
+   [projects."E:\\path\\to\\repo"]
+   trust_level = "trusted"
+   ```
+
+3. Approve the Delano `SessionStart` hook when Codex asks whether to trust it.
+
+Older docs and builds may refer to `[features].codex_hooks`; newer Codex builds warn that this key is deprecated in favor of `[features].hooks`.
+
 The installable `.project/context/` pack is seeded from generic templates during packaging; it does not ship Delano's own repo-specific context files into consumer repositories.
 After install, the recommended first step is `delano onboarding`, which requires explicit approval before it reviews `AGENTS.md`.
 
@@ -174,7 +199,7 @@ delano install --no-project-state --force --yes
 
 The interactive installer presents presets for updating the runtime while preserving project state, updating only skills and project templates, full install or repair, and custom category selection.
 
-Install categories are `agent-runtime`, `skills`, `viewer`, `project-context`, `project-templates`, `project-registry`, `project-projects`, `handbook`, and `legacy-installer`. The `--no-project-state` shortcut excludes `.project/context`, `.project/projects`, and `.project/registry`.
+Install categories are `agent-runtime`, `codex-hooks`, `skills`, `viewer`, `project-context`, `project-templates`, `project-registry`, `project-projects`, `handbook`, and `legacy-installer`. The `--no-project-state` shortcut excludes `.project/context`, `.project/projects`, and `.project/registry`.
 
 ## Optional AGENTS.md / CLAUDE.md snippet
 
@@ -254,7 +279,7 @@ Before the first Actions publish, configure npm trusted publishing for `@bvdm/de
 
 The package metadata must keep `repository.url` set to `https://github.com/MajesteitBart/delano`; npm validates that value against the GitHub Actions provenance bundle.
 
-After trusted publishing is configured, publish by pushing a matching version tag such as `v0.2.3`, or run the `Publish package to npm` workflow manually from `main`. The workflow rebuilds the package payload, checks manifest drift, runs tests, dry-runs the package contents, verifies the version is not already published, and then runs `npm publish --access public` from GitHub Actions using OIDC. A manual `dry_run` input is available to run the same checks without publishing.
+After trusted publishing is configured, publish by pushing a matching version tag such as `v0.2.4`, or run the `Publish package to npm` workflow manually from `main`. The workflow rebuilds the package payload, checks manifest drift, runs tests, dry-runs the package contents, verifies the version is not already published, and then runs `npm publish --access public` from GitHub Actions using OIDC. A manual `dry_run` input is available to run the same checks without publishing.
 
 If npm publish fails after the package checks pass, verify that the npm trusted publisher settings match the repository and workflow filename exactly, and that the workflow has `id-token: write`.
 

package/assets/install-manifest.json

@@ -14,6 +14,7 @@
     ".agents/fixtures/linear/issue-snapshot.json",
     ".agents/hooks/README.md",
     ".agents/hooks/bash-worktree-fix.sh",
+    ".agents/hooks/codex-session-status.js",
     ".agents/hooks/post-tool-logger.js",
     ".agents/hooks/session-tracker.js",
     ".agents/hooks/user-prompt-logger.js",
@@ -155,6 +156,7 @@
     ".agents/validation-fixtures/strict/invalid/stale-context/context.md",
     ".agents/validation-fixtures/strict/manifest.json",
     ".agents/validation-fixtures/strict/valid/minimal-project/task.md",
+    ".codex/hooks.json",
     ".delano/README.md",
     ".delano/viewer/README.md",
     ".delano/viewer/server.js",

package/assets/payload/.agents/hooks/README.md

@@ -7,5 +7,10 @@ Default hooks:
 - `post-tool-logger.js`
 - `user-prompt-logger.js`
 - `bash-worktree-fix.sh`
+- `codex-session-status.js`
 
-All hooks append JSONL records in `.agents/logs/`.
+The logging hooks append JSONL records in `.agents/logs/`.
+
+`codex-session-status.js` is used by the optional `.codex/hooks.json` SessionStart
+configuration. It emits `delano status --open --brief` context and fails open if
+the local runtime is not available.

package/assets/payload/.agents/hooks/codex-session-status.js

@@ -0,0 +1,123 @@
+#!/usr/bin/env node
+const { existsSync } = require("node:fs");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+
+function findDelanoRoot(startDir) {
+  let current = path.resolve(startDir);
+  while (true) {
+    if (
+      existsSync(path.join(current, ".project", "projects")) &&
+      existsSync(path.join(current, ".agents", "scripts", "pm", "status.sh"))
+    ) {
+      return current;
+    }
+
+    const parent = path.dirname(current);
+    if (parent === current) {
+      return null;
+    }
+    current = parent;
+  }
+}
+
+function toBashPath(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+
+function resolveBash() {
+  const candidates = [];
+
+  if (process.env.DELANO_BASH) {
+    candidates.push(process.env.DELANO_BASH);
+  }
+
+  if (process.platform === "win32") {
+    candidates.push(
+      "C:\\Program Files\\Git\\bin\\bash.exe",
+      "C:\\Program Files\\Git\\usr\\bin\\bash.exe"
+    );
+
+    const whereResult = spawnSync("where.exe", ["bash"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    if (whereResult.status === 0 && whereResult.stdout) {
+      candidates.push(...whereResult.stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean));
+    }
+  } else {
+    const whichResult = spawnSync("which", ["bash"], {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"]
+    });
+    if (whichResult.status === 0 && whichResult.stdout.trim()) {
+      candidates.push(whichResult.stdout.trim());
+    }
+    candidates.push("/usr/bin/bash", "/bin/bash");
+  }
+
+  return candidates.find((candidate) => candidate && existsSync(candidate)) || null;
+}
+
+const root = findDelanoRoot(process.cwd());
+const bashPath = resolveBash();
+if (!root || !bashPath) {
+  process.exit(0);
+}
+
+const statusScript = toBashPath(path.join(root, ".agents", "scripts", "pm", "status.sh"));
+const result = spawnSync(bashPath, [statusScript, "--open", "--brief"], {
+  cwd: root,
+  encoding: "utf8",
+  timeout: 4500,
+  maxBuffer: 64 * 1024
+});
+
+if (result.error || result.status !== 0) {
+  process.exit(0);
+}
+
+const statusOutput = result.stdout.trim();
+if (!statusOutput) {
+  process.exit(0);
+}
+
+const additionalContext = formatStatusContext(statusOutput);
+
+console.log(JSON.stringify({
+  hookSpecificOutput: {
+    hookEventName: "SessionStart",
+    additionalContext
+  }
+}));
+
+function formatStatusContext(rawStatusOutput) {
+  const lines = rawStatusOutput.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const projectLines = lines.filter((line) => (
+    !line.startsWith("Delano ") &&
+    !/^=+$/.test(line) &&
+    !line.startsWith("No open projects")
+  ));
+
+  if (projectLines.length === 0) {
+    return "Delano startup context. Open projects: none.";
+  }
+
+  const projects = projectLines.map(formatProjectLine);
+  return `Delano startup context. Open projects: ${projects.join("; ")}.`;
+}
+
+function formatProjectLine(line) {
+  const match = line.match(/^(\S+)\s+spec=(\S+)\s+plan=(\S+)\s+open_tasks=(\d+)\s+total_tasks=(\d+)$/);
+  if (!match) {
+    return line;
+  }
+
+  const [, slug, spec, plan, openTasks, totalTasks] = match;
+  return `${slug} (spec=${spec}, plan=${plan}, open_tasks=${openTasks}, total_tasks=${totalTasks})`;
+}
+
+module.exports = {
+  formatProjectLine,
+  formatStatusContext
+};

package/assets/payload/.agents/schemas/status-transitions.json

@@ -21,6 +21,24 @@
       "description": "A done task must not close over unresolved local dependencies.",
       "requires": ["all local depends_on task statuses are done"]
     },
+    {
+      "id": "progressed-task-requires-active-project",
+      "status": "in-progress|done",
+      "description": "A task must not start or complete while the parent project spec or plan is still planned.",
+      "requires": [
+        "spec.status is active or complete",
+        "plan.status is active or done"
+      ]
+    },
+    {
+      "id": "closed-task-set-requires-closed-project",
+      "status": "done|deferred",
+      "description": "A project with no open tasks must not remain open through stale spec or plan statuses.",
+      "requires": [
+        "spec.status is complete or deferred",
+        "plan.status is done or deferred"
+      ]
+    },
     {
       "id": "blocked-owner-check-back",
       "status": "blocked",

package/assets/payload/.agents/scripts/README.md

@@ -11,7 +11,7 @@ Compatibility path: `.claude/scripts/...` when the mirror is present.
 Critical path:
 - `init.sh`
 - `validate.sh`
-- `status.sh`
+- `status.sh` (`--open` and `--brief` are available for compact startup context)
 - `next.sh`
 - `blocked.sh`
 

package/assets/payload/.agents/scripts/check-status-transitions.mjs

@@ -15,7 +15,12 @@ if (contract.schema_version !== 1) {
   errors.push("status-transitions.json schema_version must be 1.");
 }
 const rules = Array.isArray(contract.task_rules) ? contract.task_rules : [];
-for (const requiredRule of ["ready-dependencies-done", "blocked-owner-check-back"]) {
+for (const requiredRule of [
+  "ready-dependencies-done",
+  "blocked-owner-check-back",
+  "progressed-task-requires-active-project",
+  "closed-task-set-requires-closed-project"
+]) {
   if (!rules.some((rule) => rule.id === requiredRule)) {
     errors.push(`status transition contract missing rule: ${requiredRule}`);
   }
@@ -28,16 +33,39 @@ if (transitionRequest) {
 }
 
 for (const projectDir of listDirectories(projectsRoot)) {
+  const specPath = path.join(projectDir, "spec.md");
+  const planPath = path.join(projectDir, "plan.md");
+  const specFrontmatter = existsSync(specPath) ? parseFrontmatter(specPath) : null;
+  const planFrontmatter = existsSync(planPath) ? parseFrontmatter(planPath) : null;
+  const hasProjectLifecycle = Boolean(specFrontmatter || planFrontmatter);
   const tasksDir = path.join(projectDir, "tasks");
   if (!existsSync(tasksDir)) continue;
 
   const tasks = new Map();
+  let totalTaskCount = 0;
+  let openTaskCount = 0;
+  let progressedTaskCount = 0;
   for (const taskFile of listMarkdownFiles(tasksDir)) {
     const frontmatter = parseFrontmatter(taskFile);
     const id = frontmatter.id || path.basename(taskFile, ".md").split("-").slice(0, 2).join("-");
+    const status = frontmatter.status || "";
+    totalTaskCount += 1;
+    if (!isClosedTaskStatus(status)) openTaskCount += 1;
+    if (isProgressedTaskStatus(status)) progressedTaskCount += 1;
     tasks.set(id, { file: taskFile, frontmatter });
   }
 
+  if (hasProjectLifecycle) {
+    validateProjectLifecycle({
+      projectDir,
+      specStatus: specFrontmatter?.status || "",
+      planStatus: planFrontmatter?.status || "",
+      totalTaskCount,
+      openTaskCount,
+      progressedTaskCount
+    });
+  }
+
   for (const [taskId, task] of tasks.entries()) {
     const status = task.frontmatter.status || "";
     const dependencies = parseList(task.frontmatter.depends_on || "[]");
@@ -75,7 +103,9 @@ function parseTransitionArgs(args) {
     .filter(Boolean);
   const blockedOwner = valueAfter(args, "--blocked-owner");
   const blockedCheckBack = valueAfter(args, "--blocked-check-back");
-  return { nextStatus, dependencyStatuses, blockedOwner, blockedCheckBack };
+  const specStatus = valueAfter(args, "--spec-status");
+  const planStatus = valueAfter(args, "--plan-status");
+  return { nextStatus, dependencyStatuses, blockedOwner, blockedCheckBack, specStatus, planStatus };
 }
 
 function validateTransitionRequest(request) {
@@ -87,12 +117,70 @@ function validateTransitionRequest(request) {
     }
   }
 
+  if (["in-progress", "done"].includes(request.nextStatus)) {
+    if (request.specStatus && !isActiveOrClosedSpecStatus(request.specStatus)) {
+      errors.push(`cannot transition to ${request.nextStatus} while spec status is ${request.specStatus}; expected active or complete`);
+    }
+    if (request.planStatus && !isActiveOrClosedPlanStatus(request.planStatus)) {
+      errors.push(`cannot transition to ${request.nextStatus} while plan status is ${request.planStatus}; expected active or done`);
+    }
+  }
+
   if (request.nextStatus === "blocked") {
     if (!request.blockedOwner) errors.push("cannot transition to blocked without blocked_owner");
     if (!request.blockedCheckBack) errors.push("cannot transition to blocked without blocked_check_back");
   }
 }
 
+function validateProjectLifecycle(request) {
+  const projectPath = toRepoPath(request.projectDir);
+  if (request.progressedTaskCount > 0) {
+    if (!isActiveOrClosedSpecStatus(request.specStatus)) {
+      errors.push(`${projectPath} has ${request.progressedTaskCount} progressed task(s) but spec.md status is ${describeStatus(request.specStatus)}; expected active or complete before tasks can progress.`);
+    }
+    if (!isActiveOrClosedPlanStatus(request.planStatus)) {
+      errors.push(`${projectPath} has ${request.progressedTaskCount} progressed task(s) but plan.md status is ${describeStatus(request.planStatus)}; expected active or done before tasks can progress.`);
+    }
+  }
+
+  if (request.totalTaskCount > 0 && request.openTaskCount === 0) {
+    if (!isClosedSpecStatus(request.specStatus)) {
+      errors.push(`${projectPath} has no open tasks but spec.md status is ${describeStatus(request.specStatus)}; expected complete or deferred.`);
+    }
+    if (!isClosedPlanStatus(request.planStatus)) {
+      errors.push(`${projectPath} has no open tasks but plan.md status is ${describeStatus(request.planStatus)}; expected done or deferred.`);
+    }
+  }
+}
+
+function isProgressedTaskStatus(status) {
+  return ["in-progress", "done"].includes(status);
+}
+
+function isClosedTaskStatus(status) {
+  return ["done", "deferred", "canceled"].includes(status);
+}
+
+function isActiveOrClosedSpecStatus(status) {
+  return ["active", "complete"].includes(status);
+}
+
+function isActiveOrClosedPlanStatus(status) {
+  return ["active", "done"].includes(status);
+}
+
+function isClosedSpecStatus(status) {
+  return ["complete", "deferred"].includes(status);
+}
+
+function isClosedPlanStatus(status) {
+  return ["done", "deferred"].includes(status);
+}
+
+function describeStatus(status) {
+  return status || "missing status";
+}
+
 function valueAfter(args, flag) {
   const index = args.indexOf(flag);
   if (index === -1 || index === args.length - 1) return "";

package/assets/payload/.agents/scripts/pm/status.sh

@@ -4,24 +4,92 @@ set -euo pipefail
 root="$(git rev-parse --show-toplevel 2>/dev/null || pwd)"
 cd "$root"
 
+open_only=false
+brief=false
+
+usage() {
+  cat <<'EOF'
+Usage:
+  status.sh [--open] [--brief]
+
+Options:
+  --open   Show only projects that are not closed.
+  --brief  Show one compact line per project.
+  -h, --help
+           Show this help.
+EOF
+}
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --open)
+      open_only=true
+      ;;
+    --brief)
+      brief=true
+      ;;
+    -h|--help)
+      usage
+      exit 0
+      ;;
+    *)
+      echo "Unknown status option: $1" >&2
+      usage >&2
+      exit 1
+      ;;
+  esac
+  shift
+done
+
 fm_get() {
   local file="$1"
   local key="$2"
-  awk -v key="$key" '
-    BEGIN {in_fm=0}
-    /^---[[:space:]]*$/ {if (in_fm==0) {in_fm=1; next} else {exit}}
-    in_fm==1 && $0 ~ "^" key ":[[:space:]]*" {
-      sub("^" key ":[[:space:]]*", "")
-      print
-      exit
-    }
-  ' "$file"
+  local line
+  local in_fm=0
+  while IFS= read -r line; do
+    if [[ "$line" =~ ^---[[:space:]]*$ ]]; then
+      if [[ $in_fm -eq 0 ]]; then
+        in_fm=1
+        continue
+      fi
+      return 1
+    fi
+
+    if [[ $in_fm -eq 1 && "$line" == "$key:"* ]]; then
+      local value="${line#"$key:"}"
+      value="${value#"${value%%[![:space:]]*}"}"
+      printf '%s\n' "$value"
+      return 0
+    fi
+  done < "$file"
+  return 1
 }
 
-echo "Delano portfolio status"
-echo "======================="
+is_closed_spec_status() {
+  local status="${1:-unknown}"
+  [[ "$status" == "complete" || "$status" == "deferred" ]]
+}
+
+is_closed_plan_status() {
+  local status="${1:-unknown}"
+  [[ "$status" == "done" || "$status" == "deferred" ]]
+}
+
+is_closed_task_status() {
+  local status="${1:-unknown}"
+  [[ "$status" == "done" || "$status" == "deferred" || "$status" == "canceled" ]]
+}
+
+if [[ "$open_only" == "true" ]]; then
+  echo "Delano open project status"
+  echo "=========================="
+else
+  echo "Delano portfolio status"
+  echo "======================="
+fi
 
 project_count=0
+printed_count=0
 for project_dir in .project/projects/*; do
   [[ -d "$project_dir" ]] || continue
   [[ "$(basename "$project_dir")" == ".gitkeep" ]] && continue
@@ -31,31 +99,70 @@ for project_dir in .project/projects/*; do
   spec_status="$(fm_get "$project_dir/spec.md" status 2>/dev/null || true)"
   plan_status="$(fm_get "$project_dir/plan.md" status 2>/dev/null || true)"
 
-  echo ""
-  echo "Project: $slug"
-  echo "  Spec status: ${spec_status:-unknown}"
-  echo "  Plan status: ${plan_status:-unknown}"
-
   total=0
+  open_tasks=0
+  backlog_count=0
+  ready_count=0
+  in_progress_count=0
+  review_count=0
+  done_count=0
+  blocked_count=0
+  deferred_count=0
+  canceled_count=0
+  unknown_count=0
   for task in "$project_dir"/tasks/*.md; do
     [[ -f "$task" ]] || continue
+    status="$(fm_get "$task" status 2>/dev/null || true)"
     total=$((total + 1))
+    if ! is_closed_task_status "$status"; then
+      open_tasks=$((open_tasks + 1))
+    fi
+    case "$status" in
+      backlog) backlog_count=$((backlog_count + 1)) ;;
+      ready) ready_count=$((ready_count + 1)) ;;
+      in-progress) in_progress_count=$((in_progress_count + 1)) ;;
+      review) review_count=$((review_count + 1)) ;;
+      done) done_count=$((done_count + 1)) ;;
+      blocked) blocked_count=$((blocked_count + 1)) ;;
+      deferred) deferred_count=$((deferred_count + 1)) ;;
+      canceled) canceled_count=$((canceled_count + 1)) ;;
+      *) unknown_count=$((unknown_count + 1)) ;;
+    esac
   done
 
-  for st in backlog ready in-progress review done blocked canceled; do
-    count=0
-    for task in "$project_dir"/tasks/*.md; do
-      [[ -f "$task" ]] || continue
-      status="$(fm_get "$task" status 2>/dev/null || true)"
-      if [[ "$status" == "$st" ]]; then
-        count=$((count + 1))
-      fi
-    done
-    [[ $count -gt 0 ]] && echo "  $st: $count"
-  done
-  echo "  total tasks: $total"
+  project_open=false
+  if ! is_closed_spec_status "$spec_status" || ! is_closed_plan_status "$plan_status" || [[ $open_tasks -gt 0 ]]; then
+    project_open=true
+  fi
+
+  if [[ "$open_only" == "true" && "$project_open" != "true" ]]; then
+    continue
+  fi
+
+  printed_count=$((printed_count + 1))
+
+  if [[ "$brief" == "true" ]]; then
+    echo "${slug}  spec=${spec_status:-unknown} plan=${plan_status:-unknown} open_tasks=${open_tasks} total_tasks=${total}"
+  else
+    echo ""
+    echo "Project: $slug"
+    echo "  Spec status: ${spec_status:-unknown}"
+    echo "  Plan status: ${plan_status:-unknown}"
+    [[ $backlog_count -gt 0 ]] && echo "  backlog: $backlog_count"
+    [[ $ready_count -gt 0 ]] && echo "  ready: $ready_count"
+    [[ $in_progress_count -gt 0 ]] && echo "  in-progress: $in_progress_count"
+    [[ $review_count -gt 0 ]] && echo "  review: $review_count"
+    [[ $done_count -gt 0 ]] && echo "  done: $done_count"
+    [[ $blocked_count -gt 0 ]] && echo "  blocked: $blocked_count"
+    [[ $deferred_count -gt 0 ]] && echo "  deferred: $deferred_count"
+    [[ $canceled_count -gt 0 ]] && echo "  canceled: $canceled_count"
+    [[ $unknown_count -gt 0 ]] && echo "  unknown: $unknown_count"
+    echo "  total tasks: $total"
+  fi
 done
 
 if [[ $project_count -eq 0 ]]; then
   echo "No projects found. Create one with: .agents/scripts/pm/init.sh <slug> <project-name>"
+elif [[ "$open_only" == "true" && $printed_count -eq 0 ]]; then
+  echo "No open projects found."
 fi

package/assets/payload/.agents/scripts/pm/validate.sh

@@ -497,6 +497,8 @@ fi
 
 if [[ -n "$status_transition_check" ]]; then
   echo ""
+  echo "Project lifecycle and status transition check"
+  echo "---------------------------------------------"
   if command -v node >/dev/null 2>&1; then
     if node "$status_transition_check"; then
       true