cc-devflow 4.5.10 → 4.5.12

package/.claude/skills/cc-do/scripts/cc-do-common.sh

@@ -1,16 +1,15 @@
 #!/usr/bin/env bash
 
 # ------------------------------------------------------------
-# cc-do: canonical devflow layout 解析
+# cc-do: task.md only path helpers
 # ------------------------------------------------------------
 
 req_do_resolve_change_dir() {
   local input="$1"
-  local normalized
+  local normalized="${input%/}"
 
-  normalized="${input%/}"
   case "$(basename "$normalized")" in
-    planning|execution|review|handoff|meta)
+    handoff)
       dirname "$normalized"
       ;;
     *)
@@ -19,61 +18,10 @@ req_do_resolve_change_dir() {
   esac
 }
 
-req_do_planning_dir() {
-  printf '%s/planning\n' "$(req_do_resolve_change_dir "$1")"
-}
-
-req_do_execution_dir() {
-  printf '%s/execution\n' "$(req_do_resolve_change_dir "$1")"
-}
-
-req_do_review_dir() {
-  printf '%s/review\n' "$(req_do_resolve_change_dir "$1")"
+req_do_tasks_path() {
+  printf '%s/task.md\n' "$(req_do_resolve_change_dir "$1")"
 }
 
 req_do_handoff_dir() {
   printf '%s/handoff\n' "$(req_do_resolve_change_dir "$1")"
 }
-
-req_do_manifest_path() {
-  printf '%s/task-manifest.json\n' "$(req_do_planning_dir "$1")"
-}
-
-req_do_tasks_path() {
-  printf '%s/tasks.md\n' "$(req_do_planning_dir "$1")"
-}
-
-req_do_change_meta_path() {
-  printf '%s/change-meta.json\n' "$(req_do_resolve_change_dir "$1")"
-}
-
-req_do_contract_path() {
-  local planning_dir
-  local design_file
-  local analysis_file
-
-  planning_dir="$(req_do_planning_dir "$1")"
-  design_file="$planning_dir/design.md"
-  analysis_file="$planning_dir/analysis.md"
-
-  if [[ -f "$analysis_file" && ! -f "$design_file" ]]; then
-    printf '%s\n' "$analysis_file"
-    return 0
-  fi
-
-  printf '%s\n' "$design_file"
-}
-
-req_do_report_card_path() {
-  printf '%s/report-card.json\n' "$(req_do_review_dir "$1")"
-}
-
-req_do_resume_index_path() {
-  printf '%s/resume-index.md\n' "$(req_do_handoff_dir "$1")"
-}
-
-req_do_task_runtime_dir() {
-  local change_dir="$1"
-  local task_id="$2"
-  printf '%s/tasks/%s\n' "$(req_do_execution_dir "$change_dir")" "$task_id"
-}

package/.claude/skills/cc-do/scripts/check-task-status.sh

@@ -2,25 +2,17 @@
 
 set -euo pipefail
 
-# ------------------------------------------------------------
-# 查询 manifest / TASKS 的任务状态
-# ------------------------------------------------------------
-
 usage() {
   cat <<'EOF'
-Usage:
-  check-task-status.sh --manifest task-manifest.json [--task T001]
-  check-task-status.sh --tasks tasks.md [--task T001]
+Usage: check-task-status.sh --tasks task.md [--task T001]
 EOF
 }
 
 TASKS=""
-MANIFEST=""
 TASK_ID=""
 
 while [[ $# -gt 0 ]]; do
   case "$1" in
-    --manifest) MANIFEST="$2"; shift 2 ;;
     --tasks) TASKS="$2"; shift 2 ;;
     --task) TASK_ID="$(echo "$2" | tr '[:lower:]' '[:upper:]')"; shift 2 ;;
     -h|--help) usage; exit 0 ;;
@@ -28,65 +20,43 @@ while [[ $# -gt 0 ]]; do
   esac
 done
 
-if [[ -n "$MANIFEST" ]]; then
-  if [[ ! -f "$MANIFEST" ]]; then
-    usage
-    exit 1
-  fi
-
-  if [[ -n "$TASK_ID" ]]; then
-    output="$(jq -r --arg task "$TASK_ID" '
-      def normalized_status:
-        .status // (if (.completed // false) then "passed" else "pending" end);
-      def review_status($gate):
-        (.reviews[$gate].status // .reviews[$gate] // "pending");
-      [.tasks[] | select(.id == $task) | "id=\(.id) status=\(normalized_status) phase=\(.phase // 0) dependsOn=\((.dependsOn // []) | join(",")) parallel=\(.parallel // false) spec=\(review_status("spec")) code=\(review_status("code"))"] | .[0] // empty
-    ' "$MANIFEST")"
-
-    if [[ -z "$output" ]]; then
-      echo "$TASK_ID not_found"
-      exit 1
-    fi
-
-    echo "$output"
-    exit 0
-  fi
-
-  jq -r '
-    def normalized_status:
-      .status // (if (.completed // false) then "passed" else "pending" end);
-    {
-      currentTaskId: (.currentTaskId // "none"),
-      passed: ([.tasks[] | select((normalized_status == "passed") or (normalized_status == "completed") or (normalized_status == "done") or (normalized_status == "verified"))] | length),
-      running: ([.tasks[] | select(normalized_status == "running")] | length),
-      pending: ([.tasks[] | select(normalized_status == "pending")] | length),
-      blocked: ([.tasks[] | select((normalized_status == "blocked") or (normalized_status == "failed") or (normalized_status == "skipped"))] | length),
-      total: (.tasks | length)
-    }
-    | "current=\(.currentTaskId) passed=\(.passed) running=\(.running) pending=\(.pending) blocked=\(.blocked) total=\(.total)"
-  ' "$MANIFEST"
-  exit 0
-fi
-
 if [[ -z "$TASKS" || ! -f "$TASKS" ]]; then
   usage
   exit 1
 fi
 
-if [[ -n "$TASK_ID" ]]; then
-  if rg -n "^- \\[x\\].*$TASK_ID" "$TASKS" >/dev/null 2>&1; then
-    echo "$TASK_ID complete"
-    exit 0
-  fi
-  if rg -n "^- \\[ \\].*$TASK_ID" "$TASKS" >/dev/null 2>&1; then
-    echo "$TASK_ID pending"
-    exit 0
-  fi
-  echo "$TASK_ID not_found"
-  exit 1
-fi
+node - "$TASKS" "$TASK_ID" <<'NODE'
+const fs = require('fs');
+
+const tasksPath = process.argv[2];
+const requested = process.argv[3] || '';
+const text = fs.readFileSync(tasksPath, 'utf8');
+const tasks = [];
+
+for (const line of text.split(/\r?\n/)) {
+  const match = line.match(/^\s*-\s+\[( |x|X)\]\s+(T\d{3})\b\s*(.*)$/);
+  if (!match) continue;
+  tasks.push({
+    id: match[2],
+    title: match[3].trim(),
+    status: match[1].toLowerCase() === 'x' ? 'done' : 'pending'
+  });
+}
+
+const payload = requested
+  ? tasks.find((task) => task.id === requested) || null
+  : {
+      taskFile: tasksPath,
+      total: tasks.length,
+      done: tasks.filter((task) => task.status === 'done').length,
+      pending: tasks.filter((task) => task.status === 'pending').length,
+      next: tasks.find((task) => task.status === 'pending') || null
+    };
+
+if (requested && !payload) {
+  process.stderr.write(`${requested} not found\n`);
+  process.exit(1);
+}
 
-done_count="$(grep -c '^- \[x\]' "$TASKS" 2>/dev/null || echo 0)"
-todo_count="$(grep -c '^- \[ \]' "$TASKS" 2>/dev/null || echo 0)"
-total=$((done_count + todo_count))
-echo "done=$done_count todo=$todo_count total=$total"
+process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+NODE

package/.claude/skills/cc-do/scripts/mark-task-complete.sh

@@ -3,13 +3,13 @@
 set -euo pipefail
 
 # ------------------------------------------------------------
-# 把任务标记为完成，并同步 manifest / TASKS
+# 把 task.md 中的任务标记为完成
 # ------------------------------------------------------------
 
 usage() {
   cat <<'EOF'
 Usage:
-  mark-task-complete.sh --manifest task-manifest.json [--tasks tasks.md] --task T001
+  mark-task-complete.sh --tasks task.md --task T001
 EOF
 }
 
@@ -47,13 +47,11 @@ mark_first_task_complete() {
 }
 
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-MANIFEST=""
 TASKS=""
 TASK_ID=""
 
 while [[ $# -gt 0 ]]; do
   case "$1" in
-    --manifest) MANIFEST="$2"; shift 2 ;;
     --tasks) TASKS="$2"; shift 2 ;;
     --task) TASK_ID="$(echo "$2" | tr '[:lower:]' '[:upper:]')"; shift 2 ;;
     -h|--help) usage; exit 0 ;;
@@ -61,53 +59,18 @@ while [[ $# -gt 0 ]]; do
   esac
 done
 
-if [[ -z "$TASK_ID" || (-z "$MANIFEST" && -z "$TASKS") ]]; then
+if [[ -z "$TASK_ID" || -z "$TASKS" ]]; then
   usage
   exit 1
 fi
 
-if [[ -n "$MANIFEST" ]]; then
-  if [[ ! -f "$MANIFEST" ]]; then
-    usage
-    exit 1
-  fi
-
-  req_dir="$(cd "$(dirname "$MANIFEST")" && pwd)"
-  "$SCRIPT_DIR/verify-task-gates.sh" --dir "$req_dir" --task "$TASK_ID" >/dev/null
-
-  tmp_manifest="$(mktemp)"
-  jq --arg task "$TASK_ID" '
-    .tasks |= map(
-      if .id == $task then
-        . + {
-          status: "passed",
-          reviews: ((.reviews // {}) + {spec: ((.reviews.spec // "pass") | tostring), code: ((.reviews.code // "pass") | tostring)})
-        }
-      else
-        .
-      end
-    )
-  ' "$MANIFEST" > "$tmp_manifest"
-  mv "$tmp_manifest" "$MANIFEST"
-
-  next_task="$("$SCRIPT_DIR/select-ready-tasks.sh" --manifest "$MANIFEST" | jq -r '.readyTasks[0].id // empty')"
-
-  tmp_manifest="$(mktemp)"
-  jq --arg next "$next_task" '
-    .currentTaskId = (if $next == "" then null else $next end)
-  ' "$MANIFEST" > "$tmp_manifest"
-  mv "$tmp_manifest" "$MANIFEST"
+if [[ ! -f "$TASKS" ]]; then
+  usage
+  exit 1
 fi
 
-if [[ -n "$TASKS" ]]; then
-  if [[ ! -f "$TASKS" ]]; then
-    usage
-    exit 1
-  fi
-
-  tmp_tasks="$(mktemp)"
-  mark_first_task_complete "$TASKS" "$TASK_ID" > "$tmp_tasks"
-  mv "$tmp_tasks" "$TASKS"
-fi
+tmp_tasks="$(mktemp)"
+mark_first_task_complete "$TASKS" "$TASK_ID" > "$tmp_tasks"
+mv "$tmp_tasks" "$TASKS"
 
 echo "Marked $TASK_ID complete"

package/.claude/skills/cc-do/scripts/select-ready-tasks.sh

@@ -3,133 +3,65 @@
 set -euo pipefail
 
 # ------------------------------------------------------------
-# 根据 manifest 选出当前 ready tasks / 并行候选
+# 从 task.md 选出第一个未完成任务
 # ------------------------------------------------------------
 
 usage() {
   cat <<'EOF'
-Usage: select-ready-tasks.sh --manifest task-manifest.json [--task T001]
+Usage: select-ready-tasks.sh --tasks task.md [--task T001]
 EOF
 }
 
-MANIFEST=""
+TASKS=""
 TASK_ID=""
 
 while [[ $# -gt 0 ]]; do
   case "$1" in
-    --manifest) MANIFEST="$2"; shift 2 ;;
+    --tasks) TASKS="$2"; shift 2 ;;
     --task) TASK_ID="$(echo "$2" | tr '[:lower:]' '[:upper:]')"; shift 2 ;;
     -h|--help) usage; exit 0 ;;
     *) echo "Unknown arg: $1" >&2; usage; exit 1 ;;
   esac
 done
 
-if [[ -z "$MANIFEST" || ! -f "$MANIFEST" ]]; then
+if [[ -z "$TASKS" || ! -f "$TASKS" ]]; then
   usage
   exit 1
 fi
 
-node - "$MANIFEST" "$TASK_ID" <<'NODE'
+node - "$TASKS" "$TASK_ID" <<'NODE'
 const fs = require('fs');
 
-const manifestPath = process.argv[2];
-const taskId = process.argv[3] || '';
-const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
-const tasks = Array.isArray(manifest.tasks) ? manifest.tasks : [];
-const doneStates = new Set(['passed', 'completed', 'done', 'verified']);
-const blockedStates = new Set(['failed', 'skipped', 'blocked']);
-
-function statusOf(task) {
-  if (task.status) return task.status;
-  return task.completed ? 'passed' : 'pending';
-}
-
-const taskMap = new Map(tasks.map((task) => [task.id, task]));
-const unfinished = tasks.filter((task) => !doneStates.has(statusOf(task)));
-const phases = unfinished.map((task) => Number.isFinite(task.phase) ? task.phase : 0);
-const activePhase = phases.length > 0 ? Math.min(...phases) : null;
-
-function unmetDependencies(task) {
-  return (task.dependsOn || []).filter((depId) => {
-    const depTask = taskMap.get(depId);
-    return !depTask || !doneStates.has(statusOf(depTask));
+const tasksPath = process.argv[2];
+const requestedTask = process.argv[3] || '';
+const text = fs.readFileSync(tasksPath, 'utf8');
+const tasks = [];
+
+for (const line of text.split(/\r?\n/)) {
+  const match = line.match(/^- \[( |x|X)\]\s+(T\d{3})\b\s*(.*)$/);
+  if (!match) continue;
+  const [, mark, id, title] = match;
+  tasks.push({
+    id,
+    title: title.trim(),
+    status: mark.toLowerCase() === 'x' ? 'passed' : 'pending'
   });
 }
 
-function summarize(task) {
-  return {
-    id: task.id,
-    title: task.title,
-    phase: task.phase || 0,
-    status: statusOf(task),
-    dependsOn: task.dependsOn || [],
-    parallel: Boolean(task.parallel),
-    touches: task.touches || task.files || [],
-    waitingOn: unmetDependencies(task)
-  };
-}
-
-const runningTasks = unfinished
-  .filter((task) => (activePhase === null || (task.phase || 0) === activePhase) && statusOf(task) === 'running')
-  .map(summarize);
-
-const readyTasks = unfinished
-  .filter((task) => {
-    const taskPhase = task.phase || 0;
-    const status = statusOf(task);
-    return (
-      (activePhase === null || taskPhase === activePhase) &&
-      status === 'pending' &&
-      unmetDependencies(task).length === 0
-    );
-  })
-  .map(summarize);
-
-const blockedTasks = unfinished
-  .filter((task) => {
-    const taskPhase = task.phase || 0;
-    const status = statusOf(task);
-    return (
-      (activePhase === null || taskPhase === activePhase) &&
-      (unmetDependencies(task).length > 0 || blockedStates.has(status))
-    );
-  })
-  .map(summarize);
-
-const deferredTasks = unfinished
-  .filter((task) => activePhase !== null && (task.phase || 0) !== activePhase)
-  .map(summarize);
-
-const payload = {
-  changeId: manifest.changeId || manifest.requirementId || 'unknown',
-  currentTaskId: manifest.currentTaskId || null,
-  activePhase,
-  runningTasks,
-  readyTasks,
-  parallelCandidates: readyTasks.filter((task) => task.parallel),
-  blockedTasks,
-  deferredTasks
-};
-
-if (taskId) {
-  const task = tasks.find((item) => item.id === taskId);
+if (requestedTask) {
+  const task = tasks.find((item) => item.id === requestedTask);
   if (!task) {
-    process.stderr.write(`${taskId} not found\n`);
+    process.stderr.write(`${requestedTask} not found\n`);
     process.exit(1);
   }
-
-  const summary = summarize(task);
-  process.stdout.write(JSON.stringify({
-    changeId: payload.changeId,
-    activePhase,
-    task: {
-      ...summary,
-      ready: readyTasks.some((item) => item.id === taskId),
-      running: runningTasks.some((item) => item.id === taskId)
-    }
-  }, null, 2) + '\n');
+  process.stdout.write(`${JSON.stringify({ task, ready: task.status === 'pending' }, null, 2)}\n`);
   process.exit(0);
 }
 
-process.stdout.write(JSON.stringify(payload, null, 2) + '\n');
+process.stdout.write(`${JSON.stringify({
+  taskFile: tasksPath,
+  readyTasks: tasks.filter((task) => task.status === 'pending').slice(0, 1),
+  openTasks: tasks.filter((task) => task.status === 'pending'),
+  completedTasks: tasks.filter((task) => task.status === 'passed')
+}, null, 2)}\n`);
 NODE

package/.claude/skills/cc-investigate/CHANGELOG.md

@@ -1,5 +1,28 @@
 # CC-Investigate Skill Changelog
 
+## v1.6.1 - 2026-05-13
+
+- simplify the investigation artifact contract to `task.md` plus Git history
+- remove legacy process-file filename lists from the root-cause handoff rules
+
+## v1.5.3 - 2026-05-13
+
+- require repair task blocks to be written directly from `assets/TASKS_TEMPLATE.md`; shorthand TODO tasks are invalid and rejected before machine JSON generation
+- clarify that task document budgets are advisory only and must not cause deletion of root-cause proof, evidence chain, repair boundary, verification, completion, or required task fields
+
+## v1.5.2 - 2026-05-13
+
+- route investigation workflow commands through the shared `resolve-cc-devflow.sh` CLI resolver before freezing machine artifacts
+- fail closed when the available CLI lacks `query workflow-context`, `task-contract`, `next-change-key`, or `review`
+- update root-cause task templates so machine JSON generation cannot fall back to simulated adapter output
+
+## v1.5.1 - 2026-05-13
+
+- slim the public `SKILL.md` entrypoint into a thin root-cause contract with conditional escalation packs
+- make CLI-owned machine artifacts a hard rule: AI writes `planning/tasks.md#Root Cause Contract`, then runs `cc-devflow task-contract compile` / `validate` for `task-manifest.json` and `change-meta.json`
+- add CLI compile support for Root Cause Contract handoffs so investigations do not require hand-authored JSON
+- internalize investigation operating rules: assumptions first, evidence over guesses, explicit conflict choice, reroute spec/roadmap ambiguity, and loud Evidence Requests
+
 ## v1.5.0 - 2026-05-13
 
 - collapse default investigation output to `planning/tasks.md` plus CLI-generated `task-manifest.json` and `change-meta.json`