npm - monomind - Versions diffs - 2.7.12 → 2.7.13 - Mend

monomind 2.7.12 → 2.7.13

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1159) hide show

package/packages/@monomind/cli/.claude/skills/mastermind-instance/SKILL.md DELETED Viewed

@@ -1,235 +0,0 @@
----
-name: mastermind-instance
-description: Mastermind instance — global instance-level settings including scheduler heartbeat management across all orgs, system-wide configuration, and cross-org health overview.
-type: domain-skill
-default_mode: auto
----
-# Mastermind Instance
-This skill is invoked by `mastermind:instance` or directly via `/mastermind:instance`.
----
-## Inputs
-- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
-- `action`: show | heartbeats | toggle-heartbeat | set | health
-- `agent_id`: agent id (required for toggle-heartbeat)
-- `org_name`: org filter (optional)
-- `key`: config key to set (for `set` action)
-- `value`: value to set
-- `caller`: command | master
----
-## Step 0 — Brain Load (standalone only)
-If `caller` is not "command", load brain context following mastermind-protocol/SKILL.md Brain Load Procedure with namespace: `ops`.
----
-## Step 1 — Load Instance Config
-```bash
-instanceFile=".monomind/instance.json"
-if [ ! -f "$instanceFile" ]; then
-  cat > "$instanceFile" <<'EOF'
-{
-  "version": "1.0",
-  "scheduler": {
-    "enabled": true,
-    "default_heartbeat_interval": 900,
-    "max_concurrent_heartbeats": 4
-  },
-  "limits": {
-    "max_orgs": 20,
-    "max_agents_per_org": 50,
-    "max_tokens_per_day": 10000000
-  },
-  "heartbeat_agents": []
-}
-EOF
-fi
-```
----
-## Step 2 — Execute Action
-### show (default)
-Display global instance configuration:
-```bash
-echo "MONOMIND INSTANCE SETTINGS"
-echo "──────────────────────────────────────────"
-jq -r '
-  "  Version:                 \(.version // "1.0")",
-  "  Scheduler enabled:       \(.scheduler.enabled // true)",
-  "  Heartbeat interval:      \(.scheduler.default_heartbeat_interval // 900)s",
-  "  Max concurrent beats:    \(.scheduler.max_concurrent_heartbeats // 4)",
-  "",
-  "LIMITS",
-  "  Max orgs:                \(.limits.max_orgs // 20)",
-  "  Max agents/org:          \(.limits.max_agents_per_org // 50)",
-  "  Max tokens/day:          \(.limits.max_tokens_per_day // 10000000)"
-' "$instanceFile"
-echo ""
-echo "ORGS"
-orgs=$(ls .monomind/orgs/*.json 2>/dev/null | grep -vE -- '-approvals|-state|-activity|-goals|-routines|-projects|-members|-issues|-workspaces|-worktrees|-environments|-plugins|-adapters|-bootstrap|-threads|-budgets|-project-workspaces|-approval-comments' | wc -l | tr -d ' ')
-echo "  Active orgs: $orgs"
-```
-### heartbeats
-<!-- LEGACY-ORG-V1: role-level heartbeat scheduling is a v1 org concept — v2 orgs run on `schedule` via the daemon instead. -->
-List all agents across all orgs that have scheduled heartbeats:
-```bash
-echo "SCHEDULER HEARTBEATS"
-echo "────────────────────────────────────────────────────────"
-printf "%-20s %-20s %-14s %-10s %s\n" "ORG" "AGENT" "INTERVAL" "ENABLED" "LAST RUN"
-echo "────────────────────────────────────────────────────────"
-found=0
-for orgF in .monomind/orgs/*.json; do
-  [[ "$orgF" == *-state* || "$orgF" == *-goals* || "$orgF" == *-routines* || "$orgF" == *-approvals* ]] && continue
-  [[ "$orgF" == *-projects* || "$orgF" == *-worktrees* || "$orgF" == *-members* || "$orgF" == *-adapters* ]] && continue
-  [[ "$orgF" == *-plugins* || "$orgF" == *-bootstrap* || "$orgF" == *-activity* ]] && continue
-  [[ "$orgF" == *-issues* || "$orgF" == *-workspaces* || "$orgF" == *-environments* ]] && continue
-  orgName=$(basename "$orgF" .json)
-  [ -n "$org_name" ] && [ "$orgName" != "$org_name" ] && continue
-  stateFile=".monomind/orgs/${orgName}-state.json"
-  jq -r --arg org "$orgName" '
-    (.roles // [])[] |
-    select(.heartbeat.enabled == true or (.runtimeConfig.heartbeat.enabled == true)) |
-    [$org, .id,
-     ((.heartbeat.interval // .runtimeConfig.heartbeat.interval // "900") | tostring) + "s",
-     "yes",
-     "-"]
-    | @tsv' "$orgF" 2>/dev/null | while IFS=$'\t' read -r org agent interval enabled lastrun; do
-    printf "%-20s %-20s %-14s %-10s %s\n" "$org" "$agent" "$interval" "$enabled" "$lastrun"
-    found=$((found + 1))
-  done
-done
-[ "$found" -eq 0 ] && echo "  No scheduled heartbeat agents found. Configure via /mastermind:heartbeatv1."
-```
-### toggle-heartbeat
-<!-- LEGACY-ORG-V1: role-level heartbeat scheduling is a v1 org concept. -->
-Enable or disable the scheduler heartbeat for a specific agent:
-```bash
-[ -z "$agent_id" ] && { echo "ERROR: --agent-id required."; exit 1; }
-[ -z "$org_name" ] && { echo "ERROR: --org required."; exit 1; }
-orgFile=".monomind/orgs/${org_name}.json"
-[ ! -f "$orgFile" ] && { echo "ERROR: Org '${org_name}' not found."; exit 1; }
-# Get current state
-current=$(jq -r --arg id "$agent_id" \
-  '(.roles // [])[] | select(.id == $id) | .heartbeat.enabled // false' "$orgFile" 2>/dev/null || echo "false")
-newState=$([ "$current" = "true" ] && echo "false" || echo "true")
-tmp="${orgFile}.tmp"
-jq --arg id "$agent_id" --argjson enabled "$newState" \
-  '.roles = [(.roles // [])[] | if .id == $id then .heartbeat.enabled = $enabled else . end]' \
-  "$orgFile" > "$tmp" && mv "$tmp" "$orgFile"
-echo "Heartbeat for '$agent_id' → $([ "$newState" = "true" ] && echo 'ENABLED' || echo 'DISABLED')"
-```
-### set
-Update an instance-level config value:
-```bash
-[ -z "$key" ] && { echo "ERROR: --key required."; exit 1; }
-[ -z "$value" ] && { echo "ERROR: --value required."; exit 1; }
-tmp="${instanceFile}.tmp"
-case "$key" in
-  scheduler.enabled)
-    jq --argjson v "$([ "$value" = "true" ] && echo true || echo false)" '.scheduler.enabled = $v' "$instanceFile" > "$tmp" ;;
-  scheduler.default_heartbeat_interval)
-    [[ "$value" =~ ^[0-9]+$ ]] || { echo "ERROR: value must be integer seconds."; exit 1; }
-    jq --argjson v "$value" '.scheduler.default_heartbeat_interval = $v' "$instanceFile" > "$tmp" ;;
-  scheduler.max_concurrent_heartbeats)
-    [[ "$value" =~ ^[0-9]+$ ]] || { echo "ERROR: value must be integer."; exit 1; }
-    jq --argjson v "$value" '.scheduler.max_concurrent_heartbeats = $v' "$instanceFile" > "$tmp" ;;
-  limits.max_orgs)
-    jq --argjson v "$value" '.limits.max_orgs = $v' "$instanceFile" > "$tmp" ;;
-  limits.max_tokens_per_day)
-    jq --argjson v "$value" '.limits.max_tokens_per_day = $v' "$instanceFile" > "$tmp" ;;
-  *)
-    echo "ERROR: Unknown key '$key'. Valid keys: scheduler.enabled, scheduler.default_heartbeat_interval, scheduler.max_concurrent_heartbeats, limits.max_orgs, limits.max_tokens_per_day"
-    exit 1 ;;
-esac
-mv "$tmp" "$instanceFile"
-echo "Set: $key = $value"
-```
-### health
-Cross-org health overview:
-```bash
-echo "INSTANCE HEALTH"
-echo "────────────────────────────────────────────────────────"
-total_orgs=0
-total_running=0
-total_alerts=0
-total_pending=0
-for orgF in .monomind/orgs/*.json; do
-  [[ "$orgF" == *-state* || "$orgF" == *-goals* || "$orgF" == *-routines* || "$orgF" == *-approvals* ]] && continue
-  [[ "$orgF" == *-projects* || "$orgF" == *-worktrees* || "$orgF" == *-members* || "$orgF" == *-adapters* ]] && continue
-  [[ "$orgF" == *-plugins* || "$orgF" == *-bootstrap* || "$orgF" == *-activity* ]] && continue
-  [[ "$orgF" == *-issues* || "$orgF" == *-workspaces* || "$orgF" == *-environments* ]] && continue
-  orgName=$(basename "$orgF" .json)
-  total_orgs=$((total_orgs + 1))
-  stateFile=".monomind/orgs/${orgName}-state.json"
-  approvalsFile=".monomind/orgs/${orgName}-approvals.json"
-  if [ -f "$stateFile" ]; then
-    running=$(jq '[.agents // {} | to_entries[] | select(.value.status == "running")] | length' "$stateFile" 2>/dev/null || echo 0)
-    total_running=$((total_running + running))
-  fi
-  if [ -f "$approvalsFile" ]; then
-    pending=$(jq '[(.approvals // [])[] | select(.status == "pending")] | length' "$approvalsFile" 2>/dev/null || echo 0)
-    total_pending=$((total_pending + pending))
-  fi
-done
-echo "  Total orgs:       $total_orgs"
-echo "  Running agents:   $total_running"
-echo "  Pending approvals:$total_pending"
-echo ""
-[ "$total_running" -gt 0 ] && echo "  ✓ System is active." || echo "  ◌ No agents running."
-[ "$total_pending" -gt 0 ] && echo "  ⚠ $total_pending approval(s) need attention. Run /mastermind:inbox."
-```
----
-## Step 3 — Return Output
-```yaml
-domain: ops
-status: complete
-action: <action>
-total_orgs: <N>
-scheduler_enabled: <true|false>
-```
----
-## Step 4 — Brain Write (standalone only)
-If `caller` is not "command", follow mastermind-protocol/SKILL.md Brain Write Procedure for domain `ops`.

package/packages/@monomind/cli/.claude/skills/mastermind-instance-settings/SKILL.md DELETED Viewed

@@ -1,315 +0,0 @@
----
-name: mastermind-instance-settings
-description: Mastermind instance-settings — instance-level administration covering general settings (auth, backup retention, keyboard shortcuts, AI feedback), experimental features (liveness auto-recovery), and user→company access grants. Extends mastermind:instance with InstanceGeneralSettings, InstanceExperimentalSettings, and InstanceAccess.
-type: domain-skill
-default_mode: confirm
----
-# Mastermind Instance Settings
-This skill is invoked by `mastermind:instance-settings` or directly via `/mastermind:instance-settings`.
----
-## Inputs
-- `brain_context`: BRAIN CONTEXT block (injected by command, or loaded below if standalone)
-- `action`: show | general | experimental | access | set | toggle-liveness | preview-liveness | grant-access | revoke-access | set-admin | unset-admin
-- `key`: general setting key to update (for `set` action)
-- `value`: value to set (for `set` action)
-- `user_id`: user id (for grant-access / revoke-access / set-admin / unset-admin)
-- `org_name`: org name to grant/revoke access to (for grant-access / revoke-access)
-- `search`: search query for user lookup (for access action)
-- `caller`: command | master
----
-## General Settings Keys
-| Key | Type | Description |
-|-----|------|-------------|
-| `censorUsernameInLogs` | bool | Redact usernames from log output |
-| `keyboardShortcutsEnabled` | bool | Enable keyboard shortcut navigation |
-| `aiFeedbackSharingEnabled` | bool | Share feedback with AI provider |
-| `dailyBackupRetentionDays` | int | Days to keep daily backups |
-| `weeklyBackupRetentionWeeks` | int | Weeks to keep weekly backups |
-| `monthlyBackupRetentionMonths` | int | Months to keep monthly backups |
-## Experimental Settings
-| Key | Type | Description |
-|-----|------|-------------|
-| `livenessAutoRecoveryEnabled` | bool | Auto-create recovery tasks for stalled issues |
-| `livenessAutoRecoveryLookbackHours` | int | Hours to look back for stalled issues |
----
-## Step 0 — Brain Load (standalone only)
-If `caller` is not "command", load brain context following mastermind-protocol/SKILL.md Brain Load Procedure with namespace: `ops`.
----
-## Step 1 — Load Instance Config
-```bash
-instanceFile=".monomind/instance.json"
-[ ! -f "$instanceFile" ] && echo '{"general":{},"experimental":{},"access":{"users":[]}}' > "$instanceFile"
-```
----
-## Step 2 — Execute Action
-### show (default)
-```bash
-echo "INSTANCE SETTINGS"
-echo "────────────────────────────────────────────────────────"
-general=$(jq -r '.general // {}' "$instanceFile")
-exp=$(jq -r '.experimental // {}' "$instanceFile")
-echo "GENERAL"
-echo "  censorUsernameInLogs:          $(echo "$general" | jq -r '.censorUsernameInLogs // false')"
-echo "  keyboardShortcutsEnabled:      $(echo "$general" | jq -r '.keyboardShortcutsEnabled // true')"
-echo "  aiFeedbackSharingEnabled:      $(echo "$general" | jq -r '.aiFeedbackSharingEnabled // false')"
-echo "  dailyBackupRetentionDays:      $(echo "$general" | jq -r '.dailyBackupRetentionDays // 7')"
-echo "  weeklyBackupRetentionWeeks:    $(echo "$general" | jq -r '.weeklyBackupRetentionWeeks // 4')"
-echo "  monthlyBackupRetentionMonths:  $(echo "$general" | jq -r '.monthlyBackupRetentionMonths // 12')"
-echo ""
-echo "EXPERIMENTAL"
-echo "  livenessAutoRecoveryEnabled:         $(echo "$exp" | jq -r '.livenessAutoRecoveryEnabled // false')"
-echo "  livenessAutoRecoveryLookbackHours:   $(echo "$exp" | jq -r '.livenessAutoRecoveryLookbackHours // 24')"
-echo ""
-echo "  To modify: --action set --key <key> --value <value>"
-echo "  To view users: --action access"
-```
-### general
-```bash
-echo "GENERAL SETTINGS"
-echo "────────────────────────────────────────────────────────"
-jq -r '.general // {}' "$instanceFile" | jq .
-echo ""
-echo "BACKUP RETENTION PRESETS"
-echo "  Daily:   7d / 14d / 30d / 60d / 90d"
-echo "  Weekly:  4w / 8w / 12w / 26w / 52w"
-echo "  Monthly: 3m / 6m / 12m / 24m"
-```
-### experimental
-```bash
-echo "EXPERIMENTAL SETTINGS"
-echo "────────────────────────────────────────────────────────"
-jq -r '.experimental // {}' "$instanceFile" | jq .
-enabled=$(jq -r '.experimental.livenessAutoRecoveryEnabled // false' "$instanceFile")
-hours=$(jq -r '.experimental.livenessAutoRecoveryLookbackHours // 24' "$instanceFile")
-echo ""
-echo "LIVENESS AUTO-RECOVERY"
-echo "  Enabled:        $enabled"
-echo "  Lookback hours: $hours"
-echo ""
-echo "  Toggle: --action toggle-liveness"
-echo "  Preview: --action preview-liveness"
-```
-### set
-```bash
-[ -z "$key" ] && { echo "ERROR: --key required."; exit 1; }
-[ -z "$value" ] && { echo "ERROR: --value required."; exit 1; }
-# Determine target section
-section="general"
-case "$key" in
-  livenessAutoRecovery*) section="experimental" ;;
-esac
-# Coerce booleans and integers
-typedValue="$value"
-case "$value" in
-  true|false) typedValue=$(echo "$value") ;;
-  *[0-9]*) echo "$value" | grep -qE '^[0-9]+$' && typedValue="$value" ;;
-esac
-tmp="${instanceFile}.tmp"
-jq --arg section "$section" --arg k "$key" --argjson v "$(
-  if echo "$typedValue" | grep -qE '^(true|false|[0-9]+)$'; then echo "$typedValue"; else echo "\"$typedValue\""; fi
-)" \
-  '.[$section][$k] = $v' \
-  "$instanceFile" > "$tmp" && mv "$tmp" "$instanceFile"
-echo "Instance setting updated: [$section] $key = $typedValue"
-```
-### toggle-liveness
-```bash
-current=$(jq -r '.experimental.livenessAutoRecoveryEnabled // false' "$instanceFile")
-if [ "$current" = "true" ]; then
-  newVal=false
-else
-  newVal=true
-fi
-tmp="${instanceFile}.tmp"
-jq --argjson v "$newVal" '.experimental.livenessAutoRecoveryEnabled = $v' \
-  "$instanceFile" > "$tmp" && mv "$tmp" "$instanceFile"
-echo "Liveness auto-recovery toggled: $newVal"
-```
-### preview-liveness
-```bash
-hours=$(jq -r '.experimental.livenessAutoRecoveryLookbackHours // 24' "$instanceFile")
-echo "LIVENESS AUTO-RECOVERY PREVIEW"
-echo "  Lookback: last ${hours} hours"
-echo "────────────────────────────────────────────────────────"
-echo "  (Preview runs against live issue graph.)"
-echo "  To enable: --action toggle-liveness"
-echo ""
-echo "  Checking activity files for stalled issues…"
-cutoff=$(date -u -v-${hours}H +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || date -u --date="${hours} hours ago" +%Y-%m-%dT%H:%M:%SZ 2>/dev/null)
-# Count potentially stalled issues across all orgs
-stalledCount=0
-for issuesFile in .monomind/orgs/*-issues.json; do
-  [ -f "$issuesFile" ] || continue
-  cnt=$(jq --arg cutoff "$cutoff" \
-    '[(.issues // [])[] | select(.status == "in_progress" and (.lastActivityAt // .createdAt // "") < $cutoff)] | length' \
-    "$issuesFile" 2>/dev/null || echo 0)
-  stalledCount=$((stalledCount + cnt))
-done
-echo "  Potentially stalled issues (in_progress, no activity since cutoff): $stalledCount"
-[ "$stalledCount" -gt 0 ] && echo "  Run --action toggle-liveness to enable auto-recovery."
-```
-### access
-```bash
-search="${search:-}"
-accessFile=".monomind/instance-access.json"
-[ ! -f "$accessFile" ] && echo '{"users":[]}' > "$accessFile"
-echo "INSTANCE ACCESS — USER DIRECTORY"
-echo "  Search: ${search:-(all)}"
-echo "────────────────────────────────────────────────────────"
-printf "%-32s %-20s %-10s %s\n" "USER ID" "NAME" "ADMIN" "COMPANIES"
-echo "────────────────────────────────────────────────────────"
-jq -r --arg q "$search" '.users[] |
-  select($q == "" or (.id | ascii_downcase | contains($q | ascii_downcase))
-    or (.name // "" | ascii_downcase | contains($q | ascii_downcase))) |
-  [.id, (.name // "(unnamed)"), (if .isInstanceAdmin then "yes" else "no" end),
-   ((.companyAccess // []) | length | tostring)] | @tsv' \
-  "$accessFile" | while IFS=$'\t' read -r uid name admin count; do
-  printf "%-32s %-20s %-10s %s orgs\n" "$uid" "$name" "$admin" "$count"
-done
-echo ""
-echo "  Grant org access: --action grant-access --user-id <uid> --org-name <org>"
-echo "  Revoke org access: --action revoke-access --user-id <uid> --org-name <org>"
-echo "  Make instance admin: --action set-admin --user-id <uid>"
-```
-### grant-access
-```bash
-[ -z "$user_id" ] && { echo "ERROR: --user-id required."; exit 1; }
-[ -z "$org_name" ] && { echo "ERROR: --org-name required."; exit 1; }
-accessFile=".monomind/instance-access.json"
-[ ! -f "$accessFile" ] && echo '{"users":[]}' > "$accessFile"
-ts=$(date -u +%Y-%m-%dT%H:%M:%SZ)
-tmp="${accessFile}.tmp"
-jq --arg uid "$user_id" --arg org "$org_name" --arg ts "$ts" \
-  '.users = (
-    if any((.users // [])[]; .id == $uid) then
-      [(.users // [])[] | if .id == $uid then
-        .companyAccess = ((.companyAccess // []) | if any(.[]; . == $org) then . else . + [$org] end)
-      else . end]
-    else
-      (.users // []) + [{"id": $uid, "companyAccess": [$org], "isInstanceAdmin": false, "grantedAt": $ts}]
-    end)' \
-  "$accessFile" > "$tmp" && mv "$tmp" "$accessFile"
-echo "Access granted: user '$user_id' → org '$org_name'"
-```
-### revoke-access
-```bash
-[ -z "$user_id" ] && { echo "ERROR: --user-id required."; exit 1; }
-[ -z "$org_name" ] && { echo "ERROR: --org-name required."; exit 1; }
-accessFile=".monomind/instance-access.json"
-[ ! -f "$accessFile" ] && { echo "No access file found."; exit 1; }
-tmp="${accessFile}.tmp"
-jq --arg uid "$user_id" --arg org "$org_name" \
-  '.users = [(.users // [])[] | if .id == $uid then
-     .companyAccess = [(.companyAccess // [])[] | select(. != $org)]
-   else . end]' \
-  "$accessFile" > "$tmp" && mv "$tmp" "$accessFile"
-echo "Access revoked: user '$user_id' from org '$org_name'"
-```
-### set-admin
-```bash
-[ -z "$user_id" ] && { echo "ERROR: --user-id required."; exit 1; }
-accessFile=".monomind/instance-access.json"
-[ ! -f "$accessFile" ] && echo '{"users":[]}' > "$accessFile"
-tmp="${accessFile}.tmp"
-jq --arg uid "$user_id" \
-  '.users = (if any((.users // [])[]; .id == $uid) then
-    [(.users // [])[] | if .id == $uid then .isInstanceAdmin = true else . end]
-  else (.users // []) + [{"id":$uid,"companyAccess":[],"isInstanceAdmin":true}] end)' \
-  "$accessFile" > "$tmp" && mv "$tmp" "$accessFile"
-echo "User '$user_id' granted instance admin role."
-```
-### unset-admin
-```bash
-[ -z "$user_id" ] && { echo "ERROR: --user-id required."; exit 1; }
-accessFile=".monomind/instance-access.json"
-tmp="${accessFile}.tmp"
-jq --arg uid "$user_id" \
-  '.users = [(.users // [])[] | if .id == $uid then .isInstanceAdmin = false else . end]' \
-  "$accessFile" > "$tmp" && mv "$tmp" "$accessFile"
-echo "Instance admin revoked for user '$user_id'."
-```
----
-## Step 3 — Return Output
-```yaml
-domain: ops
-status: complete
-action: <action>
-```
----
-## Step 4 — Brain Write (standalone only)
-If `caller` is not "command", follow mastermind-protocol/SKILL.md Brain Write Procedure for domain `ops`.

package/packages/@monomind/cli/.claude/skills/mastermind-intake/SKILL.md DELETED Viewed

@@ -1,83 +0,0 @@
----
-name: mastermind-intake
-description: Shared intake protocol for mastermind — rich-prompt detection, comprehensive intake questions asked one at a time, and LLM-decide logic. Never invoked directly; called by master and standalone domain commands.
-type: shared
----
-# Mastermind Intake Protocol
-This file is referenced by `master.md` and domain commands. Never invoke directly.
----
-## Rich Prompt Detection
-Count the words in `$ARGUMENTS` and scan for domain signals.
-**Rich prompt** (skip all intake questions → proceed to execution):
-- Word count ≥ 20 AND
-- Contains at least one domain signal (build, ship, feature, bug, fix, campaign, marketing, SEO, content, review, audit, research, launch, release, sales, outreach, ops, finance, report) AND
-- Contains a goal or outcome phrase (e.g. "so that", "by end of", "targeting", "for our", "to improve")
-**Vague prompt** (run intake): anything that doesn't meet rich-prompt criteria.
-Even with a rich prompt, if `--confirm` flag is present: skip to execution but show the plan before spawning agents and wait for "go".
----
-## Intake Questions
-Ask ONE question at a time. Wait for the answer before asking the next. Stop asking as soon as you have enough to proceed.
-**Q1 — Goal:**
-> "What outcome defines success for this run? Be as specific as you can — what will be done or produced when we're finished?"
-**Q2 — Scope:**
-> "Which business domains should this touch? Options: build, idea, marketing, review, research, content, release, sales, ops, finance — or should I decide based on the goal?"
-**Q3 — Constraints:**
-> "Any constraints I should know about? Examples: don't touch production, stay within this codebase, only content work this week, timeline by end of sprint."
-**Q4 — Mode:**
-> "Should I execute automatically once I have a plan, or show you the plan first and wait for your approval before spawning agents?"
-**Q5 — Project:**
-> "Which project is this for? I'll create or find a monotask space with that name. (Or I can infer it from context.)"
-Skip Q4 if `--auto` or `--confirm` flag was provided. Skip Q5 if `--project <name>` flag was provided.
----
-## LLM-Decide Rule
-If the user responds with any of: "decide yourself", "you decide", "your call", "whatever you think", "up to you" — to any intake question:
-1. Make an explicit decision. State it clearly:
-   > "I'm choosing [X] because [one-sentence reason]."
-2. Log this as a decision in the run's output schema with `confidence: 0.7` and `outcome: pending`.
-3. Continue immediately. Do NOT ask a follow-up on the same question.
----
-## Mode Resolution
-After intake (or skip), resolve the execution mode:
-| Flag / Answer | Mode |
-|---|---|
-| `--auto` flag | auto — spawn immediately after planning |
-| `--confirm` flag | confirm — show plan, wait for "go" |
-| Q4 answer: "auto" or "yes go ahead" | auto |
-| Q4 answer: "show me first" or "confirm" | confirm |
-| No flag, vague prompt | confirm (default for vague) |
-| No flag, rich prompt | auto (default for rich) |
----
-## Project Name Resolution
-Priority order:
-1. `--project <name>` flag — use exactly as provided
-2. Q5 answer — use as provided
-3. Infer from prompt: extract the most prominent product/project noun
-4. Fallback: use today's date as `session-YYYY-MM-DD`