@indigoai-us/hq-cli 5.345.88 → 5.345.90

package/assets/scaffold/core/scripts/hq-delegate-send.sh

@@ -34,6 +34,8 @@ HQ_ROOT="${HQ_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
 
 # shellcheck source=lib/secret-patterns.sh
 . "$SCRIPT_DIR/lib/secret-patterns.sh"
+# shellcheck source=lib/delegate-brainstorm.sh
+. "$SCRIPT_DIR/lib/delegate-brainstorm.sh"
 
 usage() { sed -n '3,27p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'; }
 die()   { echo "hq-delegate-send: $*" >&2; exit 1; }
@@ -100,12 +102,25 @@ MODE="$(jq -r '.mode // "transfer"' "$MANIFEST")"
 [ -n "$PROJECT" ]   || die "manifest has no project.name"
 [ -n "$PRINCIPAL" ] || die "manifest has no to.principal"
 
-PRD_ABS="$HQ_ROOT/$(jq -r '.project.prdPath' "$MANIFEST")"
+STAGE="$(jq -r '.project.stage // "prd"' "$MANIFEST")"
+PRD_REL="$(jq -r '.project.prdPath // empty' "$MANIFEST")"
+PRD_ABS="${PRD_REL:+$HQ_ROOT/$PRD_REL}"
+BRAINSTORM_ABS="$HQ_ROOT/companies/$COMPANY/projects/$PROJECT/brainstorm.md"
 
 # --- assemble prompt sections from the manifest (single source of truth) -----
 
 GOAL="" STATE_LINE="" NEXT_STEPS=""
-if [ -f "$PRD_ABS" ] && jq -e . "$PRD_ABS" >/dev/null 2>&1; then
+DOSSIER_LINE="Start with the project dossier: \`companies/$COMPANY/projects/$PROJECT/\` now contains the PRD (\`prd.json\`), a full brief (\`README.md\` / the DM's details pane), and the delegation journal."
+if [ "$STAGE" = brainstorm ]; then
+  # Brainstorm stage: no PRD, no stories. The next steps are to read the
+  # brainstorm and turn it into a PRD with /plan.
+  [ -f "$BRAINSTORM_ABS" ] && GOAL="$(hq_brainstorm_summary "$BRAINSTORM_ABS")"
+  STATE_LINE="This project is at the brainstorm stage: no PRD yet, no stories. The source of truth is \`companies/$COMPANY/projects/$PROJECT/brainstorm.md\`."
+  NEXT_STEPS="1. **Read the brainstorm** — \`brainstorm.md\`, the notes under \`research/\`, and the latest journal entry under \`journal/\`.
+2. **Turn it into a PRD** — run \`/plan $PROJECT\` to write \`prd.json\` with stories.
+3. **Start the first story** — once the PRD exists, \`/run-project $PROJECT\` or \`/execute-task\` picks it up."
+  DOSSIER_LINE="Start with the project dossier: \`companies/$COMPANY/projects/$PROJECT/\` contains \`brainstorm.md\`, the \`research/\` notes, the latest journal entry, a full brief (the DM's details pane), and the delegation journal. There is no \`prd.json\` yet."
+elif [ -n "$PRD_ABS" ] && [ -f "$PRD_ABS" ] && jq -e . "$PRD_ABS" >/dev/null 2>&1; then
   GOAL="$(jq -r '.metadata.goal // .description // ""' "$PRD_ABS")"
   TOTAL="$(jq -r '[.userStories // [] | .[]] | length' "$PRD_ABS")"
   DONE="$(jq -r '[.userStories // [] | .[] | select(.passes == true)] | length' "$PRD_ABS")"
@@ -195,7 +210,7 @@ trap 'rm -rf "$STAGE"; [ "$SEND" -eq 0 ] || rmdir "$LOCK"' EXIT
   printf '%s\n' "$GET_LINES"
   echo '```'
   echo
-  echo "Start with the project dossier: \`companies/$COMPANY/projects/$PROJECT/\` now contains the PRD (\`prd.json\`), a full brief (\`README.md\` / the DM's details pane), and the delegation journal."
+  echo "$DOSSIER_LINE"
   echo
   if [ -n "$REPO_SECTION" ]; then
     printf '%s\n' "$REPO_SECTION"

package/assets/scaffold/core/scripts/hq-delegate-transfer.sh

@@ -8,8 +8,12 @@
 #
 # Behavior (mode "transfer"; mode "share" skips every mutation):
 #   1. companies/<co>/board.json — the project's entry gets owner=<recipient>
-#      and a bumped updated_at; created (once) if absent
-#   2. prd.json metadata gains owner, delegatedFrom, delegatedAt
+#      and a bumped updated_at; created (once) if absent. A brainstorm-stage
+#      entry (status exploring, brainstorm_path set) is matched by
+#      brainstorm_path and keeps its status.
+#   2. prd.json metadata gains owner, delegatedFrom, delegatedAt; for a
+#      brainstorm-stage project the same three keys land in the
+#      brainstorm.md frontmatter (owner, delegated_from, delegated_at)
 #   3. work-mesh: `done` event closes the delegator's in-progress thread and
 #      broadcasts the reassignment; silently skipped when the helper is
 #      unavailable (local/offline installs) — the transfer still succeeds
@@ -32,6 +36,9 @@ HQ_ROOT="${HQ_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
 usage() { sed -n '3,25p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'; }
 die()   { echo "hq-delegate-transfer: $*" >&2; exit 1; }
 
+# shellcheck source=lib/delegate-brainstorm.sh
+. "$SCRIPT_DIR/lib/delegate-brainstorm.sh"
+
 command -v jq >/dev/null 2>&1 || die "jq is required but not installed"
 
 MANIFEST=""
@@ -68,12 +75,20 @@ jq -e '.status == "granted"' "$MANIFEST" >/dev/null || die "transfer requires co
 NOW="$(jq -r '.ownershipTransferredAt // empty' "$MANIFEST")"
 [ -n "$NOW" ] || NOW="$(date -u +%Y-%m-%dT%H:%M:%SZ)"
 TODAY="$(date -u +%Y-%m-%d)"
-PRD_PATH="companies/$COMPANY/projects/$PROJECT/prd.json"
+STAGE="$(jq -r '.project.stage // "prd"' "$MANIFEST")"
+PROJECT_REL="companies/$COMPANY/projects/$PROJECT"
+PRD_PATH="$PROJECT_REL/prd.json"
 PRD_ABS="$HQ_ROOT/$PRD_PATH"
-PROJECT_DIR="$HQ_ROOT/companies/$COMPANY/projects/$PROJECT"
+BRAINSTORM_PATH="$PROJECT_REL/brainstorm.md"
+BRAINSTORM_ABS="$HQ_ROOT/$BRAINSTORM_PATH"
+PROJECT_DIR="$HQ_ROOT/$PROJECT_REL"
 BOARD="$HQ_ROOT/companies/$COMPANY/board.json"
 
-[ -f "$PRD_ABS" ] || die "prd not found: $PRD_PATH"
+case "$STAGE" in
+  prd)        [ -f "$PRD_ABS" ] || die "prd not found: $PRD_PATH" ;;
+  brainstorm) [ -f "$BRAINSTORM_ABS" ] || die "brainstorm.md not found: $BRAINSTORM_PATH" ;;
+  *)          die "manifest project.stage is '$STAGE' — expected prd or brainstorm" ;;
+esac
 
 # --- 1. board entry: update in place, create once if absent ------------------
 
@@ -83,47 +98,72 @@ else
   echo '{"projects": []}' > "$BOARD"
 fi
 
-TITLE="$(jq -r '.name // empty' "$PRD_ABS")"
-DESC="$(jq -r '.description // ""' "$PRD_ABS" | head -c 300)"
+if [ "$STAGE" = prd ]; then
+  TITLE="$(jq -r '.name // empty' "$PRD_ABS")"
+  DESC="$(jq -r '.description // ""' "$PRD_ABS" | head -c 300)"
+  MATCH_PRD="$PRD_PATH"
+  MATCH_BS=""
+  NEW_STATUS="in_progress"
+else
+  TITLE="$(hq_brainstorm_title "$BRAINSTORM_ABS")"
+  DESC="$(hq_brainstorm_summary "$BRAINSTORM_ABS" | head -c 300)"
+  MATCH_PRD=""
+  MATCH_BS="$BRAINSTORM_PATH"
+  NEW_STATUS="exploring"
+fi
+[ -n "$TITLE" ] || TITLE="$PROJECT"
 
+# An existing entry is matched by prd_path (PRD stage) or brainstorm_path
+# (brainstorm stage). The match is by path, so a brainstorm entry whose
+# prd_path is null still updates in place and keeps its status.
 TMP_BOARD="$(mktemp)"
 jq \
-  --arg prd "$PRD_PATH" \
+  --arg prd "$MATCH_PRD" \
+  --arg bs "$MATCH_BS" \
   --arg owner "$PRINCIPAL" \
   --arg now "$NOW" \
   --arg title "$TITLE" \
   --arg desc "$DESC" \
   --arg project "$PROJECT" \
+  --arg status "$NEW_STATUS" \
   '
-  if ([.projects // [] | .[] | select(.prd_path == $prd)] | length) > 0 then
+  def matches: ($prd != "" and .prd_path == $prd) or ($bs != "" and .brainstorm_path == $bs);
+  if ([.projects // [] | .[] | select(matches)] | length) > 0 then
     .projects = [.projects[] |
-      if .prd_path == $prd then .owner = $owner | .updated_at = $now else . end]
+      if matches then .owner = $owner | .updated_at = $now else . end]
   else
     .projects = (.projects // []) + [{
       id: ("proj-" + $project),
       title: $title,
       description: $desc,
-      status: "in_progress",
+      status: $status,
       owner: $owner,
-      prd_path: $prd,
+      prd_path: (if $prd == "" then null else $prd end),
       created_at: $now,
       updated_at: $now
-    }]
+    } + (if $bs == "" then {} else {brainstorm_path: $bs} end)]
   end
   | .updated_at = $now
   ' "$BOARD" > "$TMP_BOARD" && mv "$TMP_BOARD" "$BOARD"
 
-# --- 2. prd metadata ----------------------------------------------------------
-
-TMP_PRD="$(mktemp)"
-jq \
-  --arg owner "$PRINCIPAL" \
-  --arg from "$FROM" \
-  --arg now "$NOW" \
-  '.metadata.owner = $owner
-   | .metadata.delegatedFrom = $from
-   | .metadata.delegatedAt = $now' \
-  "$PRD_ABS" > "$TMP_PRD" && mv "$TMP_PRD" "$PRD_ABS"
+# --- 2. ownership on the source of truth -------------------------------------
+# PRD stage: prd.json metadata. Brainstorm stage: brainstorm.md frontmatter.
+
+if [ "$STAGE" = prd ]; then
+  TMP_PRD="$(mktemp)"
+  jq \
+    --arg owner "$PRINCIPAL" \
+    --arg from "$FROM" \
+    --arg now "$NOW" \
+    '.metadata.owner = $owner
+     | .metadata.delegatedFrom = $from
+     | .metadata.delegatedAt = $now' \
+    "$PRD_ABS" > "$TMP_PRD" && mv "$TMP_PRD" "$PRD_ABS"
+else
+  hq_brainstorm_frontmatter_set "$BRAINSTORM_ABS" owner "$PRINCIPAL"
+  hq_brainstorm_frontmatter_set "$BRAINSTORM_ABS" delegated_from "$FROM"
+  hq_brainstorm_frontmatter_set "$BRAINSTORM_ABS" delegated_at "$NOW"
+fi
 
 # --- 3. work mesh: close the delegator's thread, broadcast reassignment ------
 # Silently tolerated when unavailable (local/offline installs no-op).
@@ -162,7 +202,11 @@ if ! grep -qF "$DELEGATION_ID" "$JOURNAL_FILE"; then
     echo "- From: $FROM"
     echo "- To: $DISPLAY ($PRINCIPAL)"
     echo "- Transferred scope: $SCOPE"
-    echo "- Local board and PRD ownership updated; Work Mesh ownership is unconfirmed. Existing delegator access is unchanged."
+    if [ "$STAGE" = prd ]; then
+      echo "- Local board and PRD ownership updated; Work Mesh ownership is unconfirmed. Existing delegator access is unchanged."
+    else
+      echo "- Brainstorm-stage project (no PRD yet). Local board and brainstorm.md ownership updated; Work Mesh ownership is unconfirmed. Existing delegator access is unchanged."
+    fi
   } >> "$JOURNAL_FILE"
 fi
 
@@ -172,4 +216,8 @@ TMP_MANIFEST="$(mktemp)"
 jq --arg now "$NOW" '.ownershipTransferredAt = $now | .workMeshOwnership = "unconfirmed"' "$MANIFEST" > "$TMP_MANIFEST" \
   && mv "$TMP_MANIFEST" "$MANIFEST"
 
-echo "hq-delegate-transfer: ownership of '$PROJECT' transferred to $DISPLAY ($PRINCIPAL) — local board, PRD, and journal updated; Work Mesh ownership unconfirmed"
+if [ "$STAGE" = prd ]; then
+  echo "hq-delegate-transfer: ownership of '$PROJECT' transferred to $DISPLAY ($PRINCIPAL) — local board, PRD, and journal updated; Work Mesh ownership unconfirmed"
+else
+  echo "hq-delegate-transfer: ownership of '$PROJECT' (brainstorm stage) transferred to $DISPLAY ($PRINCIPAL) — local board, brainstorm.md, and journal updated; Work Mesh ownership unconfirmed"
+fi

package/assets/scaffold/core/scripts/hq-delegate-verify.sh

@@ -17,7 +17,8 @@
 #   core/scripts/hq-delegate-verify.sh --dry-run \
 #     --company <slug> --project <name> --to <principal> [--mode transfer|share]
 #
-# Prints recipient, mode, every prefix with its permission, the secret
+# Prints recipient, mode, project stage (prd, or brainstorm with the dossier
+# files and the /plan next step), every prefix with its permission, the secret
 # names an .env.schema would grant, repo + branch, and the DM headline that
 # would be sent. Exits 0. Creates nothing under workspace/delegations/ and
 # invokes no mutating command.
@@ -83,6 +84,14 @@ if [ "$DRY_RUN" -eq 1 ]; then
   echo "  Mode:       $MODE"
   echo "  Company:    $COMPANY"
   echo "  Project:    $PROJECT"
+  if [ "$(printf '%s' "$PLAN_JSON" | jq -r '.project.stage // "prd"')" = brainstorm ]; then
+    echo "  Stage:      brainstorm — no PRD yet; source of truth is brainstorm.md; recommended next step is /plan $PROJECT"
+    echo
+    echo "  Dossier files that would be published:"
+    printf '%s' "$PLAN_JSON" | jq -r '.project.dossier[] | "    \(.)"'
+  else
+    echo "  Stage:      prd"
+  fi
   echo
   echo "  Vault grants that would be written:"
   printf '%s' "$PLAN_JSON" | jq -r '.vaultPrefixes[] | "    \(.permission)\ton \(.prefix)\t(\(.reason // ""))"'

package/assets/scaffold/core/scripts/hq-job-probe.sh

@@ -123,12 +123,19 @@ command -v jq >/dev/null 2>&1 || die "jq is required"
 # jq.exe on MSYS may use CRT text mode unless --binary is supported.
 case "${OSTYPE:-}:${MSYSTEM:-}" in
   msys*:*|*:MINGW*)
+    # Probe --binary once per script run, in the top-level shell. Most jq
+    # calls run inside $(...) subshells, so a cache filled lazily inside jq()
+    # would be lost and the probe would repeat on every call.
+    if command jq --binary -n 'null' >/dev/null 2>&1; then
+      HQ_JQ_BINARY_SUPPORTED=1
+    else
+      HQ_JQ_BINARY_SUPPORTED=0
+    fi
     jq() {
-      local stdout_file stderr_file status binary_supported
+      local stdout_file stderr_file status
       stdout_file="$(mktemp)" || return $?
       stderr_file="$(mktemp)" || { status=$?; rm -f "$stdout_file"; return "$status"; }
-      if command jq --binary -n 'null' >/dev/null 2>&1; then binary_supported=1; else binary_supported=0; fi
-      if [[ "$binary_supported" == 1 ]]; then
+      if [[ "$HQ_JQ_BINARY_SUPPORTED" == 1 ]]; then
         if command jq --binary "$@" >"$stdout_file" 2>"$stderr_file"; then status=0; else status=$?; fi
         command cat "$stdout_file"
         command cat "$stderr_file" >&2

package/assets/scaffold/core/scripts/jobs-validate.sh

@@ -43,12 +43,19 @@ command -v jq >/dev/null 2>&1 || {
 # jq.exe on MSYS may use CRT text mode unless --binary is supported.
 case "${OSTYPE:-}:${MSYSTEM:-}" in
   msys*:*|*:MINGW*)
+    # Probe --binary once per script run, in the top-level shell. Most jq
+    # calls run inside $(...) subshells, so a cache filled lazily inside jq()
+    # would be lost and the probe would repeat on every call.
+    if command jq --binary -n 'null' >/dev/null 2>&1; then
+      HQ_JQ_BINARY_SUPPORTED=1
+    else
+      HQ_JQ_BINARY_SUPPORTED=0
+    fi
     jq() {
-      local stdout_file stderr_file status binary_supported
+      local stdout_file stderr_file status
       stdout_file="$(mktemp)" || return $?
       stderr_file="$(mktemp)" || { status=$?; rm -f "$stdout_file"; return "$status"; }
-      if command jq --binary -n 'null' >/dev/null 2>&1; then binary_supported=1; else binary_supported=0; fi
-      if [[ "$binary_supported" == 1 ]]; then
+      if [[ "$HQ_JQ_BINARY_SUPPORTED" == 1 ]]; then
         if command jq --binary "$@" >"$stdout_file" 2>"$stderr_file"; then status=0; else status=$?; fi
         command cat "$stdout_file"
         command cat "$stderr_file" >&2

package/assets/scaffold/core/scripts/lib/delegate-brainstorm.sh

@@ -0,0 +1,120 @@
+# shellcheck shell=bash
+# hq-core: public
+# delegate-brainstorm.sh — shared readers for brainstorm-stage projects in the
+# /delegate helpers.
+#
+# SOURCED, never executed:  . "$ROOT/core/scripts/lib/delegate-brainstorm.sh"
+# bash 3.2 safe; no associative arrays, no GNU-only flags.
+#
+# A brainstorm-stage project has companies/<co>/projects/<slug>/brainstorm.md
+# and no prd.json yet (policy hq-brainstorm-leaves-handoffable-project-folder).
+# Every delegation helper that reads the PRD falls back to these readers when
+# the manifest says project.stage == "brainstorm".
+
+# Project stage from the files on disk. Prints "prd", "brainstorm", or "none".
+hq_delegate_project_stage() { # project_dir
+  if [ -f "$1/prd.json" ]; then
+    echo prd
+  elif [ -f "$1/brainstorm.md" ]; then
+    echo brainstorm
+  else
+    echo none
+  fi
+}
+
+# Value of a top-level `key: value` line inside the leading YAML frontmatter.
+# Prints nothing when the file has no frontmatter or the key is absent.
+hq_brainstorm_frontmatter_get() { # file key
+  awk -v key="$2" '
+    NR == 1 { if ($0 != "---") exit; next }
+    /^---[[:space:]]*$/ { exit }
+    {
+      split($0, kv, ":")
+      if (kv[1] == key) {
+        sub("^[^:]*:[[:space:]]*", "", $0)
+        gsub(/^"|"$/, "", $0)
+        print
+        exit
+      }
+    }' "$1"
+}
+
+# One-line summary: the first `> ` blockquote after the H1, else the first
+# non-empty prose line after the H1.
+hq_brainstorm_summary() { # file
+  awk '
+    /^# / && !seen_h1 { seen_h1 = 1; next }
+    !seen_h1 { next }
+    /^> / { sub(/^> /, ""); print; exit }
+    /^#/ { exit }
+    /^[[:space:]]*$/ { next }
+    { print; exit }' "$1"
+}
+
+# Project title: the first H1 without the leading `# `.
+hq_brainstorm_title() { # file
+  awk '/^# / { sub(/^# /, ""); print; exit }' "$1"
+}
+
+# Body of a `## <heading>` section, up to the next `## ` heading. The heading
+# is matched by prefix so `## Recommendation` also matches a decorated title.
+hq_brainstorm_section() { # file heading
+  awk -v heading="$2" '
+    /^## / {
+      if (in_section) exit
+      if (index($0, "## " heading) == 1) { in_section = 1; next }
+    }
+    in_section { print }' "$1" | sed -e '/./,$!d' | sed -e :a -e '/^\n*$/{$d;N;ba' -e '}'
+}
+
+# Newest journal note by filename, excluding the delegation log the transfer
+# step maintains. Prints the HQ-root-relative path or nothing.
+hq_brainstorm_latest_journal() { # hq_root rel_project_dir
+  local dir="$1/$2/journal" f newest="" name newest_name=""
+  [ -d "$dir" ] || return 0
+  # Bash's pathname expansion is sorted by locale like sort(1), and unlike
+  # find -maxdepth it works with both GNU and macOS/BSD find installations.
+  # Include dotfiles too: find includes them, while Bash's default glob does not.
+  for f in "$dir"/*.md "$dir"/.md "$dir"/.[!.]*.md "$dir"/..?*.md; do
+    [ -f "$f" ] || continue
+    name="${f##*/}"
+    [ "$name" = delegations.md ] && continue
+    case "$name" in *.md) ;; *) continue ;; esac
+    if [ -z "$newest" ]; then newest="$f"; newest_name="$name"; continue; fi
+    if [[ "$name" > "$newest_name" ]]; then newest="$f"; newest_name="$name"; fi
+  done
+  [ -n "$newest" ] || return 0
+  printf '%s\n' "${newest#"$1/"}"
+}
+
+# HQ-root-relative dossier paths for a brainstorm-stage project, one per line:
+# brainstorm.md, every file under research/, the newest journal note.
+hq_brainstorm_dossier() { # hq_root rel_project_dir
+  local root="$1" rel="$2"
+  printf '%s\n' "$rel/brainstorm.md"
+  if [ -d "$root/$rel/research" ]; then
+    (cd "$root" && find "$rel/research" -type f ! -name '.DS_Store' | sort)
+  fi
+  hq_brainstorm_latest_journal "$root" "$rel"
+}
+
+# Write or replace `key: value` inside the frontmatter, creating the
+# frontmatter block when the file has none. Rewrites the file in place through
+# a temp file so a failure leaves the original intact.
+hq_brainstorm_frontmatter_set() { # file key value
+  local file="$1" key="$2" value="$3" tmp
+  tmp="$(mktemp "${file}.tmp.XXXXXX")"
+  if [ "$(head -1 "$file")" = "---" ]; then
+    awk -v key="$key" -v value="$value" '
+      NR == 1 { print; next }
+      !done && /^---[[:space:]]*$/ { print key ": " value; done = 1; print; next }
+      !done {
+        split($0, kv, ":")
+        if (kv[1] == key) { print key ": " value; done = 1; next }
+      }
+      { print }' "$file" > "$tmp"
+  else
+    { printf -- '---\n%s: %s\n---\n' "$key" "$value"; cat "$file"; } > "$tmp"
+  fi
+  mv -f "$tmp" "$file"
+}

package/dist/commands/core-delegate-brainstorm.d.ts

@@ -0,0 +1,9 @@
+export type BrainstormStage = "prd" | "brainstorm" | "none";
+export declare function projectStage(projectDir: string): BrainstormStage;
+export declare function brainstormFrontmatterGet(file: string, key: string): string;
+export declare function brainstormTitle(file: string): string;
+export declare function brainstormSummary(file: string): string;
+export declare function brainstormSection(file: string, heading: string): string;
+export declare function brainstormDossier(root: string, relativeProject: string): string[];
+export declare function brainstormFrontmatterSet(file: string, key: string, value: string): void;
+//# sourceMappingURL=core-delegate-brainstorm.d.ts.map

package/dist/commands/core-delegate-brainstorm.js

@@ -0,0 +1,161 @@
+import { randomBytes } from "node:crypto";
+import * as fs from "node:fs";
+import * as path from "node:path";
+export function projectStage(projectDir) {
+    if (fs.existsSync(path.join(projectDir, "prd.json")))
+        return "prd";
+    if (fs.existsSync(path.join(projectDir, "brainstorm.md")))
+        return "brainstorm";
+    return "none";
+}
+export function brainstormFrontmatterGet(file, key) {
+    const lines = fs.readFileSync(file, "utf8").split("\n");
+    if (lines[0] !== "---")
+        return "";
+    for (const line of lines.slice(1)) {
+        if (/^---[\t ]*$/.test(line))
+            break;
+        const colon = line.indexOf(":");
+        if (colon < 0 || line.slice(0, colon) !== key)
+            continue;
+        return line.slice(colon + 1).replace(/^[\t ]*/, "").replace(/^"|"$/g, "");
+    }
+    return "";
+}
+export function brainstormTitle(file) {
+    return fs.readFileSync(file, "utf8").split("\n").find((line) => line.startsWith("# "))?.slice(2) ?? "";
+}
+export function brainstormSummary(file) {
+    let seenH1 = false;
+    for (const line of fs.readFileSync(file, "utf8").split("\n")) {
+        if (!seenH1 && line.startsWith("# ")) {
+            seenH1 = true;
+            continue;
+        }
+        if (!seenH1)
+            continue;
+        if (line.startsWith("> "))
+            return line.slice(2);
+        if (line.startsWith("#"))
+            return "";
+        if (!line.trim())
+            continue;
+        return line;
+    }
+    return "";
+}
+export function brainstormSection(file, heading) {
+    const lines = fs.readFileSync(file, "utf8").split("\n");
+    const section = [];
+    let inSection = false;
+    for (const line of lines) {
+        if (line.startsWith("## ")) {
+            if (inSection)
+                break;
+            if (line.startsWith(`## ${heading}`)) {
+                inSection = true;
+                continue;
+            }
+        }
+        if (inSection)
+            section.push(line);
+    }
+    while (section[0] === "")
+        section.shift();
+    while (section.at(-1) === "")
+        section.pop();
+    return section.join("\n");
+}
+function filesBelow(directory) {
+    if (!fs.existsSync(directory) || !fs.statSync(directory).isDirectory())
+        return [];
+    const files = [];
+    const visit = (current) => {
+        for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
+            const target = path.join(current, entry.name);
+            if (entry.isDirectory())
+                visit(target);
+            else if (entry.isFile() && entry.name !== ".DS_Store")
+                files.push(target);
+        }
+    };
+    visit(directory);
+    return files;
+}
+export function brainstormDossier(root, relativeProject) {
+    const projectDir = path.join(root, relativeProject);
+    const result = [`${relativeProject}/brainstorm.md`];
+    result.push(...filesBelow(path.join(projectDir, "research"))
+        .map((file) => path.relative(root, file).split(path.sep).join("/")).sort());
+    const journal = path.join(projectDir, "journal");
+    if (fs.existsSync(journal) && fs.statSync(journal).isDirectory()) {
+        const newest = fs.readdirSync(journal)
+            .filter((name) => name.endsWith(".md") && name !== "delegations.md" && isRegularFile(path.join(journal, name)))
+            .sort().at(-1);
+        if (newest)
+            result.push(`${relativeProject}/journal/${newest}`);
+    }
+    return result;
+}
+function isRegularFile(file) {
+    try {
+        return fs.statSync(file).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+export function brainstormFrontmatterSet(file, key, value) {
+    const contents = fs.readFileSync(file, "utf8");
+    const lines = contents.split("\n");
+    let output;
+    if (lines[0] === "---") {
+        output = [];
+        let done = false;
+        let closed = false;
+        for (let index = 0; index < lines.length; index += 1) {
+            const line = lines[index] ?? "";
+            if (index === 0) {
+                output.push(line);
+                continue;
+            }
+            if (/^---[\t ]*$/.test(line)) {
+                if (!done) {
+                    output.push(`${key}: ${value}`);
+                    done = true;
+                }
+                output.push(line);
+                output.push(...lines.slice(index + 1));
+                closed = true;
+                break;
+            }
+            const colon = line.indexOf(":");
+            if (!done && colon >= 0 && line.slice(0, colon) === key) {
+                output.push(`${key}: ${value}`);
+                done = true;
+            }
+            else
+                output.push(line);
+        }
+        if (!closed)
+            output = output.length ? output : lines;
+    }
+    else {
+        output = ["---", `${key}: ${value}`, "---", ...lines];
+    }
+    const temporary = `${file}.tmp.${randomBytes(6).toString("hex")}`;
+    const rewritten = output.join("\n");
+    const contentsToWrite = lines[0] === "---" && !rewritten.endsWith("\n") ? `${rewritten}\n` : rewritten;
+    fs.writeFileSync(temporary, contentsToWrite, { mode: 0o600, flag: "wx" });
+    try {
+        fs.renameSync(temporary, file);
+    }
+    catch (error) {
+        try {
+            fs.rmSync(temporary, { force: true });
+        }
+        catch { /* retain primary failure */ }
+        throw error;
+    }
+}
+//# sourceMappingURL=core-delegate-brainstorm.js.map