@indigoai-us/hq-cli 5.345.88 → 5.345.89

package/CHANGELOG.md

@@ -2,6 +2,9 @@
 
 ## [Unreleased]
 
+## [5.345.89] — 2026-10-11
+- Delegation commands now support projects that have a brainstorm and dossier but no PRD yet. The native route and bundled shell fallback build, transfer, publish, and send the brainstorm-stage handoff consistently.
+
 ## [5.345.88] — 2026-10-11
 - Work Mesh no longer crash-loops through memory during an internet outage:
   failed presence and membership lookups back off and log once per drop, and a

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

@@ -16,9 +16,16 @@
 # prompt) — schema documented in
 # core/knowledge/public/hq-core/delegation-bundle-spec.md.
 #
+# Source of truth is prd.json. When the project has no prd.json yet but has a
+# brainstorm.md (a brainstorm-stage project, policy
+# hq-brainstorm-leaves-handoffable-project-folder), brainstorm.md is the source
+# of truth: the dossier is brainstorm.md, research/**, and the newest journal
+# note; the brief says so and recommends /plan as the next step.
+#
 # Fails closed (non-zero, nothing written) when:
 #   - required arguments are missing
-#   - the project directory or its prd.json does not exist / parses invalid
+#   - the project directory does not exist, or it has neither prd.json nor
+#     brainstorm.md, or its prd.json parses invalid
 #   - the generated manifest or BRIEF matches a secret-detection pattern
 #
 # Env:
@@ -31,6 +38,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,13p' "${BASH_SOURCE[0]}" | sed 's/^# \{0,1\}//'
@@ -70,10 +79,16 @@ case "$MODE" in transfer|share) ;; *) die "--mode must be transfer or share" ;;
 case "$TO_KIND" in person|agent) ;; *) die "--to-kind must be person or agent" ;; esac
 
 PROJECT_DIR="$HQ_ROOT/companies/$COMPANY/projects/$PROJECT"
+PROJECT_REL="companies/$COMPANY/projects/$PROJECT"
 PRD="$PROJECT_DIR/prd.json"
-[ -d "$PROJECT_DIR" ] || die "project directory not found: companies/$COMPANY/projects/$PROJECT"
-[ -f "$PRD" ] || die "project has no prd.json: companies/$COMPANY/projects/$PROJECT/prd.json"
-jq -e . "$PRD" >/dev/null 2>&1 || die "prd.json is not valid JSON: $PRD"
+BRAINSTORM="$PROJECT_DIR/brainstorm.md"
+[ -d "$PROJECT_DIR" ] || die "project directory not found: $PROJECT_REL"
+STAGE="$(hq_delegate_project_stage "$PROJECT_DIR")"
+case "$STAGE" in
+  prd) jq -e . "$PRD" >/dev/null 2>&1 || die "prd.json is not valid JSON: $PRD" ;;
+  brainstorm) ;;
+  *) die "project has neither prd.json nor brainstorm.md: $PROJECT_REL (run /brainstorm or /plan first)" ;;
+esac
 
 # --- identity ----------------------------------------------------------------
 
@@ -104,8 +119,14 @@ PROJECT_PREFIX="projects/$PROJECT/"
 
 # knowledge entries from prd metadata: split into vault-grantable (under this
 # company), policies (under this company's policies/), and repo-based docs
-# (recorded for the brief, never granted as vault prefixes).
-KNOWLEDGE_JSON="$(jq -c '[.metadata.knowledge // [] | .[]]' "$PRD")"
+# (recorded for the brief, never granted as vault prefixes). A brainstorm-stage
+# project keeps its research inside the project folder, so there is nothing
+# outside the dossier prefix to grant.
+if [ "$STAGE" = prd ]; then
+  KNOWLEDGE_JSON="$(jq -c '[.metadata.knowledge // [] | .[]]' "$PRD")"
+else
+  KNOWLEDGE_JSON="[]"
+fi
 
 VAULT_READ_PREFIXES="$(printf '%s' "$KNOWLEDGE_JSON" | jq -r --arg co "$COMPANY" '
   [ .[]
@@ -142,7 +163,8 @@ printf '%s' "$VAULT_PREFIXES_JSON" | jq -e '
 
 # --- repo block (recorded here; verified/pushed by the US-004 step) ----------
 
-REPO_PATH="$(jq -r '.metadata.repoPath // empty' "$PRD")"
+REPO_PATH=""
+[ "$STAGE" = prd ] && REPO_PATH="$(jq -r '.metadata.repoPath // empty' "$PRD")"
 if [ -n "$REPO_PATH" ]; then
   REPO_JSON="$(jq -cn \
     --arg path "$REPO_PATH" \
@@ -156,14 +178,33 @@ fi
 
 # --- board id ----------------------------------------------------------------
 
+# A PRD project is matched by prd_path; a brainstorm-stage entry (status
+# exploring) carries brainstorm_path and a null prd_path.
 BOARD_ID="null"
 BOARD_FILE="$HQ_ROOT/companies/$COMPANY/board.json"
 if [ -f "$BOARD_FILE" ]; then
-  BOARD_ID="$(jq --arg prd "companies/$COMPANY/projects/$PROJECT/prd.json" \
-    '[.projects // [] | .[] | select(.prd_path == $prd) | .id] | first // null' \
+  BOARD_ID="$(jq --arg prd "$PROJECT_REL/prd.json" --arg bs "$PROJECT_REL/brainstorm.md" \
+    '[.projects // [] | .[] | select(.prd_path == $prd or .brainstorm_path == $bs) | .id] | first // null' \
     "$BOARD_FILE" 2>/dev/null || echo null)"
 fi
 
+# --- stage-specific project block ---------------------------------------------
+#
+# prdPath stays the PRD contract for every downstream helper; a brainstorm-stage
+# project sets it to null, names brainstorm.md as sourcePath, and lists the
+# dossier files (brainstorm.md, research/**, newest journal note) that the
+# publish step must ship.
+
+if [ "$STAGE" = prd ]; then
+  PROJECT_JSON="$(jq -cn --arg name "$PROJECT" --arg prd "$PROJECT_REL/prd.json" --argjson boardId "$BOARD_ID" \
+    '{name: $name, stage: "prd", prdPath: $prd, sourcePath: $prd, boardId: $boardId}')"
+else
+  DOSSIER_JSON="$(hq_brainstorm_dossier "$HQ_ROOT" "$PROJECT_REL" | jq -R . | jq -cs .)"
+  PROJECT_JSON="$(jq -cn --arg name "$PROJECT" --arg bs "$PROJECT_REL/brainstorm.md" \
+    --argjson boardId "$BOARD_ID" --argjson dossier "$DOSSIER_JSON" \
+    '{name: $name, stage: "brainstorm", prdPath: null, sourcePath: $bs, boardId: $boardId, dossier: $dossier}')"
+fi
+
 # --- checksums of the project dossier ----------------------------------------
 
 CHECKSUMS_JSON="$(
@@ -176,8 +217,8 @@ CHECKSUMS_JSON="$(
 
 # --- build in a temp dir, scan, then move into place -------------------------
 
-STAGE="$(mktemp -d)"
-trap 'rm -rf "$STAGE"' EXIT
+STAGE_DIR="$(mktemp -d)"
+trap 'rm -rf "$STAGE_DIR"' EXIT
 
 jq -n \
   --arg id "$DELEGATION_ID" \
@@ -189,9 +230,7 @@ jq -n \
   --arg toPrincipal "$TO" \
   --arg toName "$TO_NAME" \
   --arg company "$COMPANY" \
-  --arg project "$PROJECT" \
-  --arg prdPath "companies/$COMPANY/projects/$PROJECT/prd.json" \
-  --argjson boardId "$BOARD_ID" \
+  --argjson project "$PROJECT_JSON" \
   --argjson vaultPrefixes "$VAULT_PREFIXES_JSON" \
   --argjson repo "$REPO_JSON" \
   --argjson knowledge "$MANIFEST_KNOWLEDGE" \
@@ -207,7 +246,7 @@ jq -n \
     to: {kind: $toKind, principal: $toPrincipal,
          displayName: (if $toName == "" then null else $toName end)},
     company: $company,
-    project: {name: $project, prdPath: $prdPath, boardId: $boardId},
+    project: $project,
     vaultPrefixes: $vaultPrefixes,
     repo: $repo,
     secrets: [],
@@ -215,10 +254,11 @@ jq -n \
     policies: $policies,
     checksums: $checksums,
     status: "building"
-  }' > "$STAGE/manifest.json"
+  }' > "$STAGE_DIR/manifest.json"
 
 # --- BRIEF.md — full prose for a reader who has never seen the project -------
 
+if [ "$STAGE" = prd ]; then
 DESCRIPTION="$(jq -r '.description // "No description recorded."' "$PRD")"
 GOAL="$(jq -r '.metadata.goal // empty' "$PRD")"
 TOTAL_STORIES="$(jq -r '[.userStories // [] | .[]] | length' "$PRD")"
@@ -278,19 +318,65 @@ TRAPS="$(jq -r '[.metadata.securityNotes // empty, (.metadata.executionConventio
   echo "## Where everything lives"
   echo
   echo "The full PRD (every story, acceptance criteria, and decision history) is at \`companies/$COMPANY/projects/$PROJECT/prd.json\`. The pickup prompt that accompanied this brief pulls every file you need on demand — you do not need to run a full sync."
-} > "$STAGE/BRIEF.md"
+} > "$STAGE_DIR/BRIEF.md"
+else
+  # Brainstorm stage: no stories, no PRD. The brief says so plainly and points
+  # the recipient at /plan.
+  SUMMARY="$(hq_brainstorm_summary "$BRAINSTORM")"
+  [ -n "$SUMMARY" ] || SUMMARY="No summary recorded in brainstorm.md."
+  RECOMMENDATION="$(hq_brainstorm_section "$BRAINSTORM" "Recommendation")"
+  UNKNOWNS="$(hq_brainstorm_section "$BRAINSTORM" "What We Don't Know")"
+  DOSSIER_LIST="$(printf '%s' "$PROJECT_JSON" | jq -r '.dossier[] | "- `" + . + "`"')"
+  {
+    echo "# Delegation brief — $PROJECT"
+    echo
+    echo "This brief describes the **$PROJECT** project in the **$COMPANY** company. Completed handoff steps are recorded in the manifest. Pull the files and acknowledge receipt; report any access error to the sender."
+    echo
+    echo "## What this project is"
+    echo
+    echo "$SUMMARY"
+    echo
+    echo "## Where things stand"
+    echo
+    echo "This project is at the brainstorm stage. There is no PRD yet and no stories have been written; the source of truth is \`$PROJECT_REL/brainstorm.md\`, with research notes and the latest session journal alongside it."
+    echo
+    if [ -n "$RECOMMENDATION" ]; then
+      echo "## Recommendation so far"
+      echo
+      echo "$RECOMMENDATION"
+      echo
+    fi
+    if [ -n "$UNKNOWNS" ]; then
+      echo "## Open questions"
+      echo
+      echo "$UNKNOWNS"
+      echo
+    fi
+    echo "## Recommended next step"
+    echo
+    echo "Run \`/plan $PROJECT\` to turn the brainstorm into a PRD with stories. Read brainstorm.md and the research notes first; the recommendation and open questions above come from them."
+    echo
+    echo "## Where everything lives"
+    echo
+    echo "The dossier for this handoff:"
+    echo
+    echo "$DOSSIER_LIST"
+    echo
+    echo "The pickup prompt that accompanied this brief pulls every file you need on demand — you do not need to run a full sync."
+  } > "$STAGE_DIR/BRIEF.md"
+fi
 
 # --- fail-closed secret scan -------------------------------------------------
 
-if ! hq_scan_secrets "$STAGE/manifest.json" "$STAGE/BRIEF.md"; then
+if ! hq_scan_secrets "$STAGE_DIR/manifest.json" "$STAGE_DIR/BRIEF.md"; then
   die "generated bundle matched a secret-detection pattern — nothing written (see stderr above)"
 fi
 
 # --- dry run: print the manifest, write nothing ------------------------------
 
 if [ "$DRY_RUN" -eq 1 ]; then
-  cat "$STAGE/manifest.json"
-  rm -rf "$STAGE"
+  cat "$STAGE_DIR/manifest.json"
+  rm -rf "$STAGE_DIR"
   trap - EXIT
   echo "hq-delegate-bundle: dry run — nothing written" >&2
   exit 0
@@ -300,7 +386,7 @@ fi
 
 DEST="$HQ_ROOT/workspace/delegations/$DELEGATION_ID"
 mkdir -p "$(dirname "$DEST")"
-mv "$STAGE" "$DEST"
+mv "$STAGE_DIR" "$DEST"
 trap - EXIT
 
 echo "$DELEGATION_ID"

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

@@ -1,10 +1,16 @@
 #!/usr/bin/env bash
 # hq-core: public
 # Publish final delegation artifacts and verify their canonical cloud bytes.
+# PRD stage snapshots prd.json, README.md, and the delegation journal.
+# Brainstorm stage (manifest project.stage == "brainstorm") snapshots the
+# manifest's dossier list (brainstorm.md, research/**, newest journal note)
+# plus the delegation journal, and checks ownership in the brainstorm.md
+# frontmatter instead of prd.json.
 set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 HQ_ROOT="${HQ_ROOT:-$(cd "$SCRIPT_DIR/../.." && pwd)}"
 . "$SCRIPT_DIR/lib/secret-patterns.sh"
+. "$SCRIPT_DIR/lib/delegate-brainstorm.sh"
 die() { echo "hq-delegate-publish: $*" >&2; exit 1; }
 [ "${1:-}" = --manifest ] && [ -f "${2:-}" ] || die 'usage: --manifest <path>'
 MANIFEST="$2"
@@ -33,10 +39,19 @@ REL="companies/$COMPANY/projects/$PROJECT"
 PROJECT_DIR="$HQ_ROOT/$REL"
 BUNDLE="$(cd "$(dirname "$MANIFEST")" && pwd)"
 [ -f "$BUNDLE/BRIEF.md" ] || die 'BRIEF.md missing'
-[ -f "$PROJECT_DIR/prd.json" ] || die 'PRD missing'
+STAGE_KIND="$(jq -r '.project.stage // "prd"' "$MANIFEST")"
+case "$STAGE_KIND" in
+  prd)        [ -f "$PROJECT_DIR/prd.json" ] || die 'PRD missing' ;;
+  brainstorm) [ -f "$PROJECT_DIR/brainstorm.md" ] || die 'brainstorm.md missing' ;;
+  *)          die "unknown project stage '$STAGE_KIND'" ;;
+esac
 if [ "$(jq -r '.mode' "$MANIFEST")" = transfer ]; then
   EXPECTED_OWNER="$(jq -r '.to.principal' "$MANIFEST")"
-  jq -e --arg owner "$EXPECTED_OWNER" '.metadata.owner == $owner' "$PROJECT_DIR/prd.json" >/dev/null || die 'local PRD owner does not match recipient'
+  if [ "$STAGE_KIND" = prd ]; then
+    jq -e --arg owner "$EXPECTED_OWNER" '.metadata.owner == $owner' "$PROJECT_DIR/prd.json" >/dev/null || die 'local PRD owner does not match recipient'
+  else
+    [ "$(hq_brainstorm_frontmatter_get "$PROJECT_DIR/brainstorm.md" owner)" = "$EXPECTED_OWNER" ] || die 'local brainstorm.md owner does not match recipient'
+  fi
 fi
 STAGE="$(mktemp -d)"
 atomic_copy() {
@@ -52,10 +67,26 @@ file_hash() {
 }
 # Snapshot final project content, excluding mutable/self-referential receipts.
 : > "$STAGE/hashes"
-for file in "$PROJECT_DIR/prd.json" "$PROJECT_DIR/README.md" "$PROJECT_DIR/journal/delegations.md"; do
-  [ -f "$file" ] || continue
+if [ "$STAGE_KIND" = prd ]; then
+  SNAPSHOT_FILES="$PROJECT_DIR/prd.json
+$PROJECT_DIR/README.md
+$PROJECT_DIR/journal/delegations.md"
+else
+  SNAPSHOT_FILES="$(jq -r '.project.dossier[]' "$MANIFEST" | sed "s|^|$HQ_ROOT/|")
+$PROJECT_DIR/journal/delegations.md"
+  # Every dossier file the manifest promised must still exist.
+  while IFS= read -r file; do
+    [ -f "$file" ] || die "dossier file missing: ${file#"$HQ_ROOT/"}"
+  done <<EOF
+$(jq -r '.project.dossier[]' "$MANIFEST" | sed "s|^|$HQ_ROOT/|")
+EOF
+fi
+while IFS= read -r file; do
+  [ -n "$file" ] && [ -f "$file" ] || continue
   jq -cn --arg key "${file#"$HQ_ROOT/"}" --arg value "$(file_hash "$file")" '{key:$key,value:$value}' >> "$STAGE/hashes"
-done
+done <<EOF
+$SNAPSHOT_FILES
+EOF
 jq -cn --arg key "$REL/delegation/$ID/BRIEF.md" --arg value "$(file_hash "$STAGE/BRIEF.md")" '{key:$key,value:$value}' >> "$STAGE/hashes"
 jq -s 'from_entries' "$STAGE/hashes" > "$STAGE/checksums"
 jq --slurpfile hashes "$STAGE/checksums" '.checksums=$hashes[0] | .status="granted" | .recipientAccess="unconfirmed" | del(.publication,.verifiedAt,.sentAt,.dmEventId)' "$MANIFEST" > "$STAGE/manifest.json"

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 // ""))"'