@mestreyoda/fabrica 0.1.0

package/genesis/scripts/impact-analysis.sh

@@ -0,0 +1,135 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Step 6: Impact analysis — cross-reference spec against project map
+# Input: stdin JSON (spec + project_map)
+# Output: JSON with impact report to stdout
+
+if [[ -n "${1:-}" && -f "${1:-}" ]]; then
+  INPUT="$(cat "$1")"
+else
+  INPUT="$(cat)"
+fi
+SESSION_ID="$(echo "$INPUT" | jq -r '.session_id')"
+IS_GREENFIELD="$(echo "$INPUT" | jq -r '.is_greenfield // false')"
+SPEC="$(echo "$INPUT" | jq '.spec // {}')"
+PROJECT_MAP="$(echo "$INPUT" | jq '.project_map // {}')"
+METADATA="$(echo "$INPUT" | jq '.metadata // {}')"
+CLASSIFICATION="$(echo "$INPUT" | jq '.classification // {}')"
+INTERVIEW="$(echo "$INPUT" | jq '.interview // {}')"
+
+echo "Running impact analysis for session $SESSION_ID..." >&2
+
+# Greenfield — no existing code to analyze
+if [[ "$IS_GREENFIELD" == "true" ]]; then
+  echo "Greenfield project — estimating new files needed" >&2
+
+  # Estimate new files from scope items
+  SCOPE_COUNT="$(echo "$SPEC" | jq '.scope_v1 | length')"
+  AC_COUNT="$(echo "$SPEC" | jq '.acceptance_criteria | length')"
+
+  jq -n \
+    --arg sid "$SESSION_ID" \
+    --argjson spec "$SPEC" \
+    --argjson map "$PROJECT_MAP" \
+    --argjson cls "$CLASSIFICATION" \
+    --argjson interview "$INTERVIEW" \
+    --argjson meta "$METADATA" \
+    --argjson sc "$SCOPE_COUNT" \
+    --argjson ac "$AC_COUNT" \
+    '{
+      session_id: $sid,
+      step: "impact",
+      impact: {
+        affected_files: [],
+        new_files_needed: ["README.md", "package.json or pyproject.toml", "src/ (main source)", "tests/ (test suite)"],
+        affected_modules: [],
+        risk_areas: ["New project — no established patterns yet"],
+        estimated_files_changed: ($sc * 2 + 4),
+        is_greenfield: true
+      },
+      spec: $spec,
+      project_map: $map,
+      classification: $cls,
+      interview: $interview,
+      metadata: $meta
+    }'
+  exit 0
+fi
+
+echo "Cross-referencing spec keywords against project symbols..." >&2
+
+# Extract keywords from spec for matching
+SPEC_KEYWORDS="$(echo "$SPEC" | jq -r '
+  [.title, .objective, (.scope_v1 // [] | .[]), (.acceptance_criteria // [] | .[])]
+  | map(select(. != null and . != "") | ascii_downcase | split(" ") | .[] | select(length > 3))
+  | unique | .[]
+')"
+
+# Get all symbols from project map
+SYMBOLS="$(echo "$PROJECT_MAP" | jq '.symbols // []')"
+FILES="$(echo "$PROJECT_MAP" | jq '[.symbols // [] | .[].file] | unique')"
+
+# Match keywords against symbol names and file paths
+AFFECTED_FILES="[]"
+AFFECTED_MODULES="[]"
+RISK_AREAS="[]"
+
+while IFS= read -r keyword; do
+  [[ -z "$keyword" ]] && continue
+
+  # Match against symbol names
+  MATCHES="$(echo "$SYMBOLS" | jq --arg kw "$keyword" '[.[] | select(.name | ascii_downcase | contains($kw)) | .file] | unique')"
+
+  if [[ "$(echo "$MATCHES" | jq 'length')" -gt 0 ]]; then
+    AFFECTED_FILES="$(echo "$AFFECTED_FILES" | jq --argjson m "$MATCHES" '. + $m | unique')"
+  fi
+
+  # Match against file paths
+  FILE_MATCHES="$(echo "$FILES" | jq --arg kw "$keyword" '[.[] | select(ascii_downcase | contains($kw))]')"
+  if [[ "$(echo "$FILE_MATCHES" | jq 'length')" -gt 0 ]]; then
+    AFFECTED_FILES="$(echo "$AFFECTED_FILES" | jq --argjson m "$FILE_MATCHES" '. + $m | unique')"
+  fi
+done <<< "$SPEC_KEYWORDS"
+
+# Extract modules (directories of affected files)
+AFFECTED_MODULES="$(echo "$AFFECTED_FILES" | jq '[.[] | split("/") | if length > 1 then .[0:-1] | join("/") else "root" end] | unique')"
+
+# Risk areas from spec
+RISK_AREAS="$(echo "$SPEC" | jq '.risks // []')"
+
+# Estimate total files changed
+AFFECTED_COUNT="$(echo "$AFFECTED_FILES" | jq 'length')"
+SCOPE_COUNT="$(echo "$SPEC" | jq '.scope_v1 | length')"
+ESTIMATED="$((AFFECTED_COUNT > SCOPE_COUNT ? AFFECTED_COUNT : SCOPE_COUNT))"
+
+echo "Impact: $AFFECTED_COUNT files matched, $ESTIMATED estimated total" >&2
+
+jq -n \
+  --arg sid "$SESSION_ID" \
+  --argjson affected "$AFFECTED_FILES" \
+  --argjson modules "$AFFECTED_MODULES" \
+  --argjson risks "$RISK_AREAS" \
+  --argjson est "$ESTIMATED" \
+  --argjson spec "$SPEC" \
+  --argjson map "$PROJECT_MAP" \
+  --argjson cls "$CLASSIFICATION" \
+  --argjson interview "$INTERVIEW" \
+  --argjson meta "$METADATA" \
+  '{
+    session_id: $sid,
+    step: "impact",
+    impact: {
+      affected_files: $affected,
+      new_files_needed: [],
+      affected_modules: $modules,
+      risk_areas: $risks,
+      estimated_files_changed: $est,
+      is_greenfield: false
+    },
+    spec: $spec,
+    project_map: $map,
+    classification: $cls,
+    interview: $interview,
+    metadata: $meta
+  }'

package/genesis/scripts/interview.sh

@@ -0,0 +1,98 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Step 3: Generate adaptive interview questions
+# Input: stdin JSON (from classify-idea.sh)
+# Output: JSON with questions array and guidelines to stdout
+# Note: This script GENERATES questions. The actual interview is conducted by
+#       the LLM via llm-task in the Lobster workflow.
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+TEMPLATES="$SCRIPT_DIR/../configs/interview-templates.json"
+
+if [[ -n "${1:-}" && -f "${1:-}" ]]; then
+  INPUT="$(cat "$1")"
+else
+  INPUT="$(cat)"
+fi
+SESSION_ID="$(echo "$INPUT" | jq -r '.session_id')"
+RAW_IDEA="$(echo "$INPUT" | jq -r '.raw_idea')"
+TYPE="$(echo "$INPUT" | jq -r '.classification.type')"
+CONFIDENCE="$(echo "$INPUT" | jq -r '.classification.confidence')"
+METADATA="$(echo "$INPUT" | jq '.metadata // {}')"
+CLASSIFICATION="$(echo "$INPUT" | jq '.classification')"
+
+echo "Generating interview questions for type=$TYPE (confidence=$CONFIDENCE)..." >&2
+
+# Get round1 questions for this type
+ROUND1="$(jq --arg t "$TYPE" '.types[$t].round1 // []' "$TEMPLATES")"
+
+# Determine detail level from the idea text length and specificity
+IDEA_LENGTH="${#RAW_IDEA}"
+if [[ "$IDEA_LENGTH" -lt 30 ]]; then
+  DETAIL_LEVEL="low"
+  echo "Short idea detected — will include follow-ups and non-technical questions" >&2
+elif [[ "$IDEA_LENGTH" -lt 100 ]]; then
+  DETAIL_LEVEL="medium"
+  echo "Medium detail — standard question set" >&2
+else
+  DETAIL_LEVEL="high"
+  echo "Detailed idea — will include technical additions" >&2
+fi
+
+# Build question set based on detail level
+# Deterministic baseline: start from required questions only.
+QUESTIONS="$(echo "$ROUND1" | jq '[.[] | select(.required == true)]')"
+
+# Detect explicit technical intent instead of relying only on text length.
+if echo "$RAW_IDEA" | grep -Eqi '(api|endpoint|sdk|lat[eê]ncia|throughput|schema|tabela|cole[cç][aã]o|banco|deploy|infra|stack|servi[cç]o externo|integra[cç][aã]o)'; then
+  TECH_SIGNAL="true"
+else
+  TECH_SIGNAL="false"
+fi
+
+if [[ "$DETAIL_LEVEL" == "high" ]]; then
+  # Add technical additions only when the user idea carries technical signals.
+  if [[ "$TECH_SIGNAL" == "true" ]]; then
+    TECH="$(jq --arg t "$TYPE" '.types[$t].technical_additions // [] | .[:1]' "$TEMPLATES")"
+    QUESTIONS="$(echo "$QUESTIONS" | jq --argjson tech "$TECH" '. + $tech')"
+  fi
+elif [[ "$DETAIL_LEVEL" == "low" ]]; then
+  # Vague idea: add at most one non-technical clarifier.
+  NON_TECH="$(jq --arg t "$TYPE" '.types[$t].non_technical_additions // [] | .[:1]' "$TEMPLATES")"
+  QUESTIONS="$(echo "$QUESTIONS" | jq --argjson nt "$NON_TECH" '. + $nt')"
+fi
+
+# Hard cap to avoid long interviews in chat channels.
+QUESTIONS="$(echo "$QUESTIONS" | jq '.[0:4]')"
+
+# If confidence is low, add questions about alternative types
+ALT_NOTE=""
+if [[ "$(echo "$CONFIDENCE < 0.6" | bc 2>/dev/null || echo 0)" == "1" ]]; then
+  ALT_NOTE="Low confidence in classification ($CONFIDENCE). Ask the user to confirm the type: is this a $TYPE, or something else?"
+fi
+
+# Guidelines for the LLM conducting the interview
+GUIDELINES="Follow SOUL.md tone. Ask only the provided questions in order. Keep language non-technical by default and only go technical if the user introduces technical constraints. Maximum 2 interview rounds. If an answer is vague and has follow_up_if_vague, use one concise follow-up. ${ALT_NOTE}"
+
+jq -n \
+  --arg sid "$SESSION_ID" \
+  --arg idea "$RAW_IDEA" \
+  --argjson cls "$CLASSIFICATION" \
+  --argjson questions "$QUESTIONS" \
+  --arg guidelines "$GUIDELINES" \
+  --arg detail "$DETAIL_LEVEL" \
+  --argjson meta "$METADATA" \
+  '{
+    session_id: $sid,
+    step: "interview",
+    raw_idea: $idea,
+    classification: $cls,
+    interview: {
+      round: 1,
+      questions: $questions,
+      detail_level: $detail,
+      guidelines: $guidelines
+    },
+    metadata: $meta
+  }'

package/genesis/scripts/map-project.sh

@@ -0,0 +1,309 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Step 5: Map project structure using project_mapper
+# Input: $1 = repo path (or stdin JSON with metadata.repo_url)
+# Output: JSON with project_map to stdout
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PYTHON="${OPENCLAW_PYTHON:-$HOME/.openclaw/.venv/bin/python3}"
+MAPPER_V3="$HOME/.openclaw/workspace/scripts/project_mapper_v3.py"
+MAPPER_V1="$HOME/.openclaw/workspace/scripts/project_mapper.py"
+source "$SCRIPT_DIR/sideband-lib.sh"
+
+PROJECT_REF_INPUT="${1:-}"
+REPO_PATH="${PROJECT_REF_INPUT}"
+SESSION_ID=""
+STATE_INPUT=""
+STATE_HAS_INPUT=false
+
+# Always try to load stdin state if present, even when $1 is set.
+# This keeps session_id/spec/metadata flowing through the pipeline.
+if [[ ! -t 0 ]]; then
+  STATE_if [[ -n "${1:-}" && -f "${1:-}" ]]; then
+  INPUT="$(cat "$1")"
+else
+  INPUT="$(cat)"
+fi
+  if [[ -n "$STATE_INPUT" ]]; then
+    STATE_HAS_INPUT=true
+    SESSION_ID="$(echo "$STATE_INPUT" | jq -r '.session_id // ""')"
+    TARGET_RESOLUTION="$(genesis_resolve_canonical_target "$STATE_INPUT" || jq -n '{metadata:{}}')"
+    STATE_INPUT="$(printf '%s' "$STATE_INPUT" | jq --argjson resolved "$TARGET_RESOLUTION" '
+      .metadata = ((.metadata // {}) + ($resolved.metadata // {}))
+    ')"
+  fi
+fi
+
+# If no $1, try reading from stdin JSON
+if [[ -z "$REPO_PATH" ]] && $STATE_HAS_INPUT; then
+  REPO_PATH="$(echo "$STATE_INPUT" | jq -r '.metadata.repo_url // .metadata.repo_path // .repo_url // .repo // ""')"
+fi
+if [[ -n "$REPO_PATH" && "$REPO_PATH" == "~"* ]]; then
+  REPO_PATH="$(genesis_expand_path "$REPO_PATH")"
+fi
+
+REPO_URL=""
+if [[ "$REPO_PATH" == http* ]]; then
+  REPO_URL="$REPO_PATH"
+fi
+
+PROJECT_SLUG=""
+PROJECT_NAME=""
+
+if $STATE_HAS_INPUT; then
+  if [[ -z "$PROJECT_SLUG" ]]; then
+    PROJECT_SLUG="$(echo "$STATE_INPUT" | jq -r '.metadata.project_slug // empty')"
+  fi
+  if [[ -z "$PROJECT_NAME" ]]; then
+    PROJECT_NAME="$(echo "$STATE_INPUT" | jq -r '.metadata.project_name // empty')"
+  fi
+fi
+
+if [[ -n "$REPO_PATH" && "$REPO_PATH" != http* ]] && [[ ! -d "$REPO_PATH" ]]; then
+  if PROJECT_REF="$(genesis_project_resolve_ref "$REPO_PATH" || true)"; then
+    PROJECT_SLUG="$(printf '%s' "$PROJECT_REF" | cut -f1)"
+    PROJECT_NAME="$(printf '%s' "$PROJECT_REF" | cut -f2)"
+    RESOLVED_REMOTE="$(printf '%s' "$PROJECT_REF" | cut -f3)"
+    RESOLVED_LOCAL="$(printf '%s' "$PROJECT_REF" | cut -f4)"
+    if [[ -n "$RESOLVED_REMOTE" ]]; then
+      REPO_URL="$RESOLVED_REMOTE"
+    fi
+    if [[ -n "$RESOLVED_LOCAL" ]]; then
+      REPO_PATH="$(genesis_expand_path "$RESOLVED_LOCAL")"
+    fi
+    echo "Resolved project reference '$PROJECT_REF_INPUT' -> slug=$PROJECT_SLUG repo=$REPO_PATH" >&2
+  fi
+fi
+
+FACTORY_INTENT_TEXT=""
+FACTORY_CHANGE_EXPLICIT=false
+if $STATE_HAS_INPUT; then
+  FACTORY_INTENT_TEXT="$(echo "$STATE_INPUT" | jq -r '[
+    .raw_idea // "",
+    .spec.title // "",
+    .spec.objective // "",
+    .classification.type // ""
+  ] | join("\n")')"
+  if genesis_payload_factory_change "$STATE_INPUT"; then
+    FACTORY_CHANGE_EXPLICIT=true
+  fi
+fi
+
+if [[ -n "$PROJECT_SLUG" ]] && genesis_is_factory_project_slug "$PROJECT_SLUG"; then
+  if [[ "$FACTORY_CHANGE_EXPLICIT" != "true" ]]; then
+    echo "ERROR: Target project \"$PROJECT_SLUG\" is reserved for Factory-internal changes. User/product requests must target a dedicated project repository." >&2
+    exit 1
+  fi
+fi
+
+if [[ -n "$PROJECT_SLUG" ]] && [[ -n "$REPO_PATH" ]] && [[ ! -d "$REPO_PATH" ]] && [[ "$REPO_PATH" != http* ]]; then
+  echo "ERROR: Registered project \"$PROJECT_SLUG\" resolved to local path \"$REPO_PATH\", but that directory does not exist. Refusing greenfield fallback." >&2
+  exit 1
+fi
+
+REMOTE_REPO_EXISTS=false
+OWNER_REPO_REMOTE=""
+
+# If repo_path is a URL, try to find local clone
+if [[ "$REPO_PATH" == http* ]]; then
+  REPO_NAME="$(basename "$REPO_PATH" .git)"
+  # Common locations for clones
+  for candidate in "./$REPO_NAME" "$HOME/$REPO_NAME" "$HOME/git/$REPO_NAME" "$HOME/projects/$REPO_NAME" "$HOME/code/$REPO_NAME"; do
+    if [[ -d "$candidate/.git" ]]; then
+      REPO_PATH="$candidate"
+      echo "Found local clone at $REPO_PATH" >&2
+      break
+    fi
+  done
+
+  OWNER_REPO_REMOTE="$(genesis_parse_owner_repo "$REPO_PATH" || true)"
+  if [[ -n "$OWNER_REPO_REMOTE" ]] && command -v gh >/dev/null 2>&1; then
+    if gh repo view "$OWNER_REPO_REMOTE" &>/dev/null; then
+      REMOTE_REPO_EXISTS=true
+      REPO_URL="https://github.com/$OWNER_REPO_REMOTE"
+      [[ -n "$PROJECT_SLUG" ]] || PROJECT_SLUG="${OWNER_REPO_REMOTE##*/}"
+      echo "Remote repository exists ($OWNER_REPO_REMOTE) even without local clone" >&2
+    fi
+  fi
+fi
+
+# If session_id is missing, keep output stable.
+if [[ -z "$SESSION_ID" ]]; then
+  SESSION_ID="unknown"
+fi
+
+# Greenfield project — no repo to map
+if [[ -z "$REPO_PATH" ]] || [[ ! -d "$REPO_PATH" ]]; then
+  if [[ "$REMOTE_REPO_EXISTS" == "true" ]]; then
+    REMOTE_PROJECT="${PROJECT_SLUG:-$(basename "${OWNER_REPO_REMOTE:-remote-project}")}"
+    REMOTE_MAP="$(jq -n \
+      --arg project "$REMOTE_PROJECT" \
+      --arg repo_url "$REPO_URL" \
+      '{
+        version: "remote-only",
+        project: $project,
+        root: null,
+        repo_url: $repo_url,
+        stats: { files_scanned: 0, symbols_found: 0, languages: [] },
+        symbols: [],
+        note: "Remote repository detected without local clone; treated as existing project."
+      }')"
+    if $STATE_HAS_INPUT; then
+      echo "$STATE_INPUT" | jq \
+        --arg sid "$SESSION_ID" \
+        --argjson map "$REMOTE_MAP" \
+        --arg repo_url "$REPO_URL" \
+        --arg project_slug "$PROJECT_SLUG" \
+        --arg project_name "$PROJECT_NAME" \
+        '. + {
+          session_id: $sid,
+          step: "map",
+          project_map: $map,
+          is_greenfield: false,
+          map_path: null,
+          metadata: (
+            (.metadata // {})
+            + (if $repo_url != "" then {repo_url: $repo_url} else {} end)
+            + (if $project_slug != "" then {project_slug: $project_slug} else {} end)
+            + (if $project_name != "" then {project_name: $project_name} else {} end)
+          )
+        }'
+    else
+      jq -n \
+        --arg sid "$SESSION_ID" \
+        --argjson map "$REMOTE_MAP" \
+        --arg repo_url "$REPO_URL" \
+        '{
+          session_id: $sid,
+          step: "map",
+          project_map: $map,
+          is_greenfield: false,
+          map_path: null,
+          metadata: { repo_url: $repo_url }
+        }'
+    fi
+    exit 0
+  fi
+
+  echo "No repository found — treating as greenfield project" >&2
+  if $STATE_HAS_INPUT; then
+    echo "$STATE_INPUT" | jq \
+      --arg sid "$SESSION_ID" \
+      '. + {
+        session_id: $sid,
+        step: "map",
+        project_map: {
+          version: "3.0",
+          project: "greenfield",
+          root: null,
+          stats: { files_scanned: 0, symbols_found: 0, languages: [] },
+          symbols: []
+        },
+        is_greenfield: true,
+        map_path: null
+      }'
+  else
+    jq -n \
+      --arg sid "$SESSION_ID" \
+      '{
+        session_id: $sid,
+        step: "map",
+        project_map: {
+          version: "3.0",
+          project: "greenfield",
+          root: null,
+          stats: { files_scanned: 0, symbols_found: 0, languages: [] },
+          symbols: []
+        },
+        is_greenfield: true,
+        map_path: null
+      }'
+  fi
+  exit 0
+fi
+
+echo "Mapping project at $REPO_PATH..." >&2
+
+MAP_OUTPUT=""
+MAP_PATH=""
+
+# Try v3 (Tree-sitter) first
+if [[ -f "$MAPPER_V3" ]] && "$PYTHON" -c "import tree_sitter" 2>/dev/null; then
+  echo "Using project_mapper_v3 (Tree-sitter)..." >&2
+  MAP_PATH="$REPO_PATH/PROJECT_MAP.json"
+  "$PYTHON" "$MAPPER_V3" "$REPO_PATH" >&2 2>&1 || true
+  if [[ -f "$MAP_PATH" ]]; then
+    MAP_OUTPUT="$(cat "$MAP_PATH")"
+  fi
+fi
+
+# Fallback to v1 (AST stdlib)
+if [[ -z "$MAP_OUTPUT" ]] && [[ -f "$MAPPER_V1" ]]; then
+  echo "Falling back to project_mapper v1 (AST stdlib)..." >&2
+  MAP_PATH="$REPO_PATH/PROJECT_MAP.json"
+  "$PYTHON" "$MAPPER_V1" "$REPO_PATH" >&2 2>&1 || true
+  if [[ -f "$MAP_PATH" ]]; then
+    MAP_OUTPUT="$(cat "$MAP_PATH")"
+  fi
+fi
+
+# If no mapper available, create a basic file listing
+if [[ -z "$MAP_OUTPUT" ]]; then
+  echo "No mapper available — generating basic file listing..." >&2
+  FILE_LIST="$(find "$REPO_PATH" -type f \
+    -not -path '*/.git/*' \
+    -not -path '*/node_modules/*' \
+    -not -path '*/__pycache__/*' \
+    -not -path '*/.venv/*' \
+    -not -path '*/venv/*' \
+    -not -path '*/dist/*' \
+    -not -path '*/build/*' \
+    2>/dev/null | head -200 | sort)"
+
+  MAP_OUTPUT="$(echo "$FILE_LIST" | jq -R -s 'split("\n") | map(select(length > 0)) | {
+    version: "1.0-basic",
+    project: "'"$(basename "$REPO_PATH")"'",
+    root: "'"$REPO_PATH"'",
+    stats: { files_scanned: length, symbols_found: 0, languages: [] },
+    symbols: [],
+    files: .
+  }')"
+fi
+
+if $STATE_HAS_INPUT; then
+  echo "$STATE_INPUT" | jq \
+    --arg sid "$SESSION_ID" \
+    --argjson map "$MAP_OUTPUT" \
+    --arg mp "${MAP_PATH:-}" \
+    --arg repo_path "$REPO_PATH" \
+    --arg repo_url "$REPO_URL" \
+    --arg project_slug "$PROJECT_SLUG" \
+    --arg project_name "$PROJECT_NAME" \
+    '. + {
+      session_id: $sid,
+      step: "map",
+      project_map: $map,
+      is_greenfield: false,
+      map_path: (if $mp != "" then $mp else null end),
+      metadata: (
+        (.metadata // {})
+        + (if $repo_url != "" then {repo_url: $repo_url} else {} end)
+        + (if $repo_path != "" and ($repo_path | startswith("http") | not) then {repo_path: $repo_path} else {} end)
+        + (if $project_slug != "" then {project_slug: $project_slug} else {} end)
+        + (if $project_name != "" then {project_name: $project_name} else {} end)
+      )
+    }'
+else
+  jq -n \
+    --arg sid "$SESSION_ID" \
+    --argjson map "$MAP_OUTPUT" \
+    --arg mp "${MAP_PATH:-}" \
+    '{
+      session_id: $sid,
+      step: "map",
+      project_map: $map,
+      is_greenfield: false,
+      map_path: (if $mp != "" then $mp else null end)
+    }'
+fi

package/genesis/scripts/receive-idea.sh

@@ -0,0 +1,69 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# Step 1: Receive and envelope a raw idea
+# Input: $1 = idea text, $2 = session_id (optional)
+# Output: JSON envelope to stdout
+
+IDEA="${1:-${GENESIS_IDEA:-}}"
+SESSION_ID="${2:-}"
+FACTORY_CHANGE_RAW="${GENESIS_FACTORY_CHANGE:-false}"
+ANSWERS_JSON_RAW="${GENESIS_ANSWERS_JSON:-}"
+
+if [[ -z "$IDEA" ]]; then
+  echo "Usage: receive-idea.sh <idea> [session-id] (or set GENESIS_IDEA)" >&2
+  exit 1
+fi
+
+if [[ -z "$SESSION_ID" ]]; then
+  SESSION_ID="$(uuidgen | tr '[:upper:]' '[:lower:]')"
+  echo "Generated session: $SESSION_ID" >&2
+fi
+
+TIMESTAMP="$(date -u +"%Y-%m-%dT%H:%M:%SZ")"
+FACTORY_CHANGE_NORMALIZED="$(printf '%s' "$FACTORY_CHANGE_RAW" | tr '[:upper:]' '[:lower:]')"
+FACTORY_CHANGE=false
+if [[ "$FACTORY_CHANGE_NORMALIZED" == "true" || "$FACTORY_CHANGE_NORMALIZED" == "1" || "$FACTORY_CHANGE_NORMALIZED" == "yes" || "$FACTORY_CHANGE_NORMALIZED" == "on" ]]; then
+  FACTORY_CHANGE=true
+fi
+
+DEFAULT_REPO_URL=""
+DEFAULT_PROJECT_NAME=""
+if [[ "$FACTORY_CHANGE" == "true" ]]; then
+  DEFAULT_REPO_URL="${GENESIS_REPO_URL:-}"
+  DEFAULT_PROJECT_NAME="${GENESIS_DEFAULT_PROJECT:-}"
+fi
+
+ANSWERS_JSON='{}'
+if [[ -n "$ANSWERS_JSON_RAW" ]]; then
+  if printf '%s' "$ANSWERS_JSON_RAW" | jq -e 'type == "object"' >/dev/null 2>&1; then
+    ANSWERS_JSON="$ANSWERS_JSON_RAW"
+  else
+    echo "WARNING: GENESIS_ANSWERS_JSON is not a valid JSON object; ignoring" >&2
+  fi
+fi
+
+jq -n \
+  --arg sid "$SESSION_ID" \
+  --arg ts "$TIMESTAMP" \
+  --arg idea "$IDEA" \
+  --arg repo "$DEFAULT_REPO_URL" \
+  --arg project "$DEFAULT_PROJECT_NAME" \
+  --arg factory_change "$FACTORY_CHANGE_RAW" \
+  --argjson answers "$ANSWERS_JSON" \
+  '{
+    session_id: $sid,
+    timestamp: $ts,
+    step: "receive",
+    raw_idea: $idea,
+    answers: $answers,
+    metadata: {
+      source: "genesis-cli",
+      repo_url: (if $repo != "" then $repo else null end),
+      project_name: (if $project != "" then $project else null end),
+      factory_change: (
+        ($factory_change | ascii_downcase) as $fc
+        | ($fc == "true" or $fc == "1" or $fc == "yes" or $fc == "on")
+      )
+    }
+  }'