crewly 1.5.15 → 1.5.16

package/config/skills/agent/browse-stealth/stealth-browse.py

@@ -285,9 +285,14 @@ def main():
         }))
         sys.exit(1)
 
-    # Ensure Chrome is running with CDP
+    # Connect to Chrome via CDP on the specified port.
+    # For custom ports, connect directly. For default port (9222), fall back to
+    # ensure_chrome_running() which can auto-launch Chrome if needed.
     try:
-        ws_url = ensure_chrome_running()
+        if args.cdp_port != CDP_PORT:
+            ws_url = get_ws_url(args.cdp_port)
+        else:
+            ws_url = ensure_chrome_running()
     except Exception as e:
         print(json.dumps({"success": False, "error": f"chrome_launch_failed: {e}"}))
         sys.exit(1)

package/config/skills/agent/core/recall/execute.sh

@@ -1,24 +1,101 @@
 #!/bin/bash
-# Retrieve stored memories relevant to a given context
+# Retrieve stored memories relevant to a given context.
+# Supports CLI flags (preferred) and legacy JSON.
 set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 source "${SCRIPT_DIR}/../../_common/lib.sh"
 
-INPUT=$(read_json_input "${1:-}")
-[ -z "$INPUT" ] && error_exit "Usage: execute.sh '{\"agentId\":\"dev-1\",\"context\":\"...\"}' or echo '{...}' | execute.sh"
-
-AGENT_ID=$(printf '%s' "$INPUT" | jq -r '.agentId // empty')
-CONTEXT=$(printf '%s' "$INPUT" | jq -r '.context // empty')
-require_param "agentId" "$AGENT_ID"
-require_param "context" "$CONTEXT"
-
-# Build body with required and optional fields
-BODY=$(printf '%s' "$INPUT" | jq '{
-  agentId: .agentId,
-  context: .context
-} +
-  (if .scope then {scope: .scope} else {} end) +
-  (if .limit then {limit: (.limit | tonumber)} else {} end) +
-  (if .projectPath then {projectPath: .projectPath} else {} end)')
+INPUT_JSON=""
+AGENT_ID=""
+CONTEXT=""
+SCOPE=""
+LIMIT=""
+PROJECT_PATH=""
+
+# Detect legacy JSON argument
+if [[ $# -gt 0 && ${1:0:1} == '{' ]]; then
+  INPUT_JSON="$1"
+  shift || true
+fi
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --agent|-a)
+      AGENT_ID="$2"
+      shift 2
+      ;;
+    --context|-c)
+      CONTEXT="$2"
+      shift 2
+      ;;
+    --scope|-s)
+      SCOPE="$2"
+      shift 2
+      ;;
+    --limit|-l)
+      LIMIT="$2"
+      shift 2
+      ;;
+    --project|-p)
+      PROJECT_PATH="$2"
+      shift 2
+      ;;
+    --json|-j)
+      INPUT_JSON="$2"
+      shift 2
+      ;;
+    --help|-h)
+      echo "Usage: execute.sh --agent dev-1 --context 'topic to recall' --project /path [--scope project|agent] [--limit 10]"
+      exit 0
+      ;;
+    --)
+      shift
+      break
+      ;;
+    *)
+      if [[ -z "$INPUT_JSON" && ${1:0:1} == '{' ]]; then
+        INPUT_JSON="$1"
+        shift
+      else
+        error_exit "Unknown argument: $1"
+      fi
+      ;;
+  esac
+done
+
+# Read from stdin if no context yet
+if [ -z "$INPUT_JSON" ] && [ -z "$CONTEXT" ] && [ ! -t 0 ]; then
+  STDIN_DATA="$(cat)"
+  if [[ ${STDIN_DATA:0:1} == '{' ]]; then
+    INPUT_JSON="$STDIN_DATA"
+  else
+    CONTEXT="$STDIN_DATA"
+  fi
+fi
+
+# Parse JSON if provided
+if [ -n "$INPUT_JSON" ]; then
+  INPUT=$(read_json_input "$INPUT_JSON")
+  [ -z "$AGENT_ID" ] && AGENT_ID=$(printf '%s' "$INPUT" | jq -r '.agentId // empty')
+  [ -z "$CONTEXT" ] && CONTEXT=$(printf '%s' "$INPUT" | jq -r '.context // empty')
+  [ -z "$SCOPE" ] && SCOPE=$(printf '%s' "$INPUT" | jq -r '.scope // empty')
+  [ -z "$LIMIT" ] && LIMIT=$(printf '%s' "$INPUT" | jq -r '.limit // empty')
+  [ -z "$PROJECT_PATH" ] && PROJECT_PATH=$(printf '%s' "$INPUT" | jq -r '.projectPath // empty')
+fi
+
+require_param "agentId (--agent)" "$AGENT_ID"
+require_param "context (--context)" "$CONTEXT"
+
+# Build body using env vars for safe escaping
+export _RCL_AGENT="$AGENT_ID"
+export _RCL_CTX="$CONTEXT"
+
+BODY=$(jq -n '{agentId: env._RCL_AGENT, context: env._RCL_CTX}')
+
+[ -n "$SCOPE" ] && BODY=$(echo "$BODY" | jq --arg s "$SCOPE" '. + {scope: $s}')
+[ -n "$LIMIT" ] && BODY=$(echo "$BODY" | jq --arg l "$LIMIT" '. + {limit: ($l | tonumber)}')
+[ -n "$PROJECT_PATH" ] && BODY=$(echo "$BODY" | jq --arg p "$PROJECT_PATH" '. + {projectPath: $p}')
+
+unset _RCL_AGENT _RCL_CTX
 
 api_call POST "/memory/recall" "$BODY"

package/config/skills/agent/core/record-learning/execute.sh

@@ -1,29 +1,98 @@
 #!/bin/bash
-# Record a learning or insight for team knowledge sharing
+# Record a learning or insight for team knowledge sharing.
+# Supports CLI flags (preferred) and legacy JSON.
 set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 source "${SCRIPT_DIR}/../../_common/lib.sh"
 
-INPUT=$(read_json_input "${1:-}")
-[ -z "$INPUT" ] && error_exit "Usage: execute.sh '{\"agentId\":\"dev-1\",\"agentRole\":\"developer\",\"projectPath\":\"...\",\"learning\":\"...\"}' or echo '{...}' | execute.sh"
-
-AGENT_ID=$(printf '%s' "$INPUT" | jq -r '.agentId // empty')
-AGENT_ROLE=$(printf '%s' "$INPUT" | jq -r '.agentRole // empty')
-PROJECT_PATH=$(printf '%s' "$INPUT" | jq -r '.projectPath // empty')
-LEARNING=$(printf '%s' "$INPUT" | jq -r '.learning // empty')
-require_param "agentId" "$AGENT_ID"
-require_param "agentRole" "$AGENT_ROLE"
-require_param "projectPath" "$PROJECT_PATH"
-require_param "learning" "$LEARNING"
-
-# Build body with required and optional fields
-BODY=$(printf '%s' "$INPUT" | jq '{
-  agentId: .agentId,
-  agentRole: .agentRole,
-  projectPath: .projectPath,
-  learning: .learning
-} +
-  (if .relatedTask then {relatedTask: .relatedTask} else {} end) +
-  (if .relatedFiles then {relatedFiles: .relatedFiles} else {} end)')
+INPUT_JSON=""
+AGENT_ID=""
+AGENT_ROLE=""
+PROJECT_PATH=""
+LEARNING=""
+
+# Detect legacy JSON argument
+if [[ $# -gt 0 && ${1:0:1} == '{' ]]; then
+  INPUT_JSON="$1"
+  shift || true
+fi
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --agent|-a)
+      AGENT_ID="$2"
+      shift 2
+      ;;
+    --role|-r)
+      AGENT_ROLE="$2"
+      shift 2
+      ;;
+    --project|-p)
+      PROJECT_PATH="$2"
+      shift 2
+      ;;
+    --learning|-l)
+      LEARNING="$2"
+      shift 2
+      ;;
+    --learning-file)
+      LEARNING="$(cat "$2")"
+      shift 2
+      ;;
+    --json|-j)
+      INPUT_JSON="$2"
+      shift 2
+      ;;
+    --help|-h)
+      echo "Usage: execute.sh --agent dev-1 --role developer --project /path --learning 'What I learned'"
+      exit 0
+      ;;
+    --)
+      shift
+      break
+      ;;
+    *)
+      if [[ -z "$INPUT_JSON" && ${1:0:1} == '{' ]]; then
+        INPUT_JSON="$1"
+        shift
+      else
+        error_exit "Unknown argument: $1"
+      fi
+      ;;
+  esac
+done
+
+# Read from stdin if no learning yet
+if [ -z "$INPUT_JSON" ] && [ -z "$LEARNING" ] && [ ! -t 0 ]; then
+  STDIN_DATA="$(cat)"
+  if [[ ${STDIN_DATA:0:1} == '{' ]]; then
+    INPUT_JSON="$STDIN_DATA"
+  else
+    LEARNING="$STDIN_DATA"
+  fi
+fi
+
+# Parse JSON if provided
+if [ -n "$INPUT_JSON" ]; then
+  INPUT=$(read_json_input "$INPUT_JSON")
+  [ -z "$AGENT_ID" ] && AGENT_ID=$(printf '%s' "$INPUT" | jq -r '.agentId // empty')
+  [ -z "$AGENT_ROLE" ] && AGENT_ROLE=$(printf '%s' "$INPUT" | jq -r '.agentRole // empty')
+  [ -z "$PROJECT_PATH" ] && PROJECT_PATH=$(printf '%s' "$INPUT" | jq -r '.projectPath // empty')
+  [ -z "$LEARNING" ] && LEARNING=$(printf '%s' "$INPUT" | jq -r '.learning // empty')
+fi
+
+require_param "agentId (--agent)" "$AGENT_ID"
+require_param "agentRole (--role)" "$AGENT_ROLE"
+require_param "projectPath (--project)" "$PROJECT_PATH"
+require_param "learning (--learning)" "$LEARNING"
+
+# Build body using env vars for safe escaping
+export _LRN_AGENT="$AGENT_ID"
+export _LRN_ROLE="$AGENT_ROLE"
+export _LRN_PROJECT="$PROJECT_PATH"
+export _LRN_CONTENT="$LEARNING"
+
+BODY=$(jq -n '{agentId: env._LRN_AGENT, agentRole: env._LRN_ROLE, projectPath: env._LRN_PROJECT, learning: env._LRN_CONTENT}')
+unset _LRN_AGENT _LRN_ROLE _LRN_PROJECT _LRN_CONTENT
 
 api_call POST "/memory/record-learning" "$BODY"

package/config/skills/agent/core/remember/execute.sh

@@ -1,35 +1,142 @@
 #!/bin/bash
-# Store a memory entry for future recall
+# Store a memory entry for future recall.
+# Supports CLI flags (preferred) and legacy JSON.
 set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 source "${SCRIPT_DIR}/../../_common/lib.sh"
 
-INPUT=$(read_json_input "${1:-}")
-[ -z "$INPUT" ] && error_exit "Usage: execute.sh '{\"agentId\":\"dev-1\",\"content\":\"...\",\"category\":\"...\",\"scope\":\"...\"}' or echo '{...}' | execute.sh"
+print_usage() {
+  cat <<'EOF_USAGE'
+Usage:
+  # CLI flags (preferred)
+  bash execute.sh --agent dev-1 --content "Important finding" --category pattern --scope project --project /path
 
-AGENT_ID=$(printf '%s' "$INPUT" | jq -r '.agentId // empty')
-CONTENT=$(printf '%s' "$INPUT" | jq -r '.content // empty')
-CATEGORY=$(printf '%s' "$INPUT" | jq -r '.category // empty')
-SCOPE=$(printf '%s' "$INPUT" | jq -r '.scope // empty')
-require_param "agentId" "$AGENT_ID"
-require_param "content" "$CONTENT"
-require_param "category" "$CATEGORY"
-require_param "scope" "$SCOPE"
+  # Content from stdin
+  echo "Multi-line finding" | bash execute.sh --agent dev-1 --category pattern --scope project --project /path
+
+  # Content from file
+  bash execute.sh --agent dev-1 --content-file /tmp/finding.txt --category pattern --scope project
+
+  # Legacy JSON (backward compatible)
+  bash execute.sh '{"agentId":"dev-1","content":"...","category":"pattern","scope":"project"}'
+
+Options:
+  --agent    | -a   Agent ID / session name (required)
+  --content  | -c   Memory content text (required unless piped via stdin)
+  --content-file    Read content from file path
+  --category | -C   Category: pattern, decision, gotcha, fact, preference (required)
+  --scope    | -s   Scope: project or agent (required)
+  --project  | -p   Project path (required for project scope)
+  --json     | -j   Raw JSON payload
+  --help     | -h   Show this help
+EOF_USAGE
+}
+
+INPUT_JSON=""
+AGENT_ID=""
+CONTENT=""
+CATEGORY=""
+SCOPE=""
+PROJECT_PATH=""
+
+# Detect legacy JSON argument
+if [[ $# -gt 0 && ${1:0:1} == '{' ]]; then
+  INPUT_JSON="$1"
+  shift || true
+fi
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --agent|-a)
+      AGENT_ID="$2"
+      shift 2
+      ;;
+    --content|-c)
+      CONTENT="$2"
+      shift 2
+      ;;
+    --content-file)
+      CONTENT="$(cat "$2")"
+      shift 2
+      ;;
+    --category|-C)
+      CATEGORY="$2"
+      shift 2
+      ;;
+    --scope|-s)
+      SCOPE="$2"
+      shift 2
+      ;;
+    --project|-p)
+      PROJECT_PATH="$2"
+      shift 2
+      ;;
+    --json|-j)
+      INPUT_JSON="$2"
+      shift 2
+      ;;
+    --help|-h)
+      print_usage
+      exit 0
+      ;;
+    --)
+      shift
+      break
+      ;;
+    *)
+      if [[ -z "$INPUT_JSON" && ${1:0:1} == '{' ]]; then
+        INPUT_JSON="$1"
+        shift
+      else
+        error_exit "Unknown argument: $1. Use --help for usage."
+      fi
+      ;;
+  esac
+done
+
+# Read from stdin if no content yet
+if [ -z "$INPUT_JSON" ] && [ -z "$CONTENT" ] && [ ! -t 0 ]; then
+  STDIN_DATA="$(cat)"
+  if [[ ${STDIN_DATA:0:1} == '{' ]]; then
+    INPUT_JSON="$STDIN_DATA"
+  else
+    CONTENT="$STDIN_DATA"
+  fi
+fi
+
+# Parse JSON if provided
+if [ -n "$INPUT_JSON" ]; then
+  INPUT=$(read_json_input "$INPUT_JSON")
+  [ -z "$AGENT_ID" ] && AGENT_ID=$(printf '%s' "$INPUT" | jq -r '.agentId // empty')
+  [ -z "$CONTENT" ] && CONTENT=$(printf '%s' "$INPUT" | jq -r '.content // empty')
+  [ -z "$CATEGORY" ] && CATEGORY=$(printf '%s' "$INPUT" | jq -r '.category // empty')
+  [ -z "$SCOPE" ] && SCOPE=$(printf '%s' "$INPUT" | jq -r '.scope // empty')
+  [ -z "$PROJECT_PATH" ] && PROJECT_PATH=$(printf '%s' "$INPUT" | jq -r '.projectPath // empty')
+fi
+
+require_param "agentId (--agent)" "$AGENT_ID"
+require_param "content (--content)" "$CONTENT"
+require_param "category (--category)" "$CATEGORY"
+require_param "scope (--scope)" "$SCOPE"
 
 # #187: Auto-inject projectPath from CREWLY_PROJECT_PATH env var when not provided
-PROJECT_PATH=$(printf '%s' "$INPUT" | jq -r '.projectPath // empty')
 if [ -z "$PROJECT_PATH" ] && [ -n "${CREWLY_PROJECT_PATH:-}" ]; then
-  INPUT=$(printf '%s' "$INPUT" | jq --arg pp "$CREWLY_PROJECT_PATH" '. + {projectPath: $pp}')
+  PROJECT_PATH="$CREWLY_PROJECT_PATH"
 fi
 
-# Build body with required and optional fields
-BODY=$(printf '%s' "$INPUT" | jq '{
-  agentId: .agentId,
-  content: .content,
-  category: .category,
-  scope: .scope
-} +
-  (if .projectPath then {projectPath: .projectPath} else {} end) +
-  (if .metadata then {metadata: .metadata} else {} end)')
+# Build body using env vars to safely handle special characters
+export _MEM_AGENT="$AGENT_ID"
+export _MEM_CONTENT="$CONTENT"
+export _MEM_CATEGORY="$CATEGORY"
+export _MEM_SCOPE="$SCOPE"
+
+if [ -n "$PROJECT_PATH" ]; then
+  export _MEM_PROJECT="$PROJECT_PATH"
+  BODY=$(jq -n '{agentId: env._MEM_AGENT, content: env._MEM_CONTENT, category: env._MEM_CATEGORY, scope: env._MEM_SCOPE, projectPath: env._MEM_PROJECT}')
+  unset _MEM_PROJECT
+else
+  BODY=$(jq -n '{agentId: env._MEM_AGENT, content: env._MEM_CONTENT, category: env._MEM_CATEGORY, scope: env._MEM_SCOPE}')
+fi
+unset _MEM_AGENT _MEM_CONTENT _MEM_CATEGORY _MEM_SCOPE
 
 api_call POST "/memory/remember" "$BODY"

package/config/skills/agent/core/report-status/execute.sh

@@ -1,26 +1,149 @@
 #!/bin/bash
 # Report task status to the orchestrator
+# Supports both CLI flags (preferred) and legacy JSON argument.
 set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 source "${SCRIPT_DIR}/../../_common/lib.sh"
 
-INPUT=$(read_json_input "${1:-}")
-[ -z "$INPUT" ] && error_exit "Usage: execute.sh '{\"sessionName\":\"dev-1\",\"status\":\"done\",\"summary\":\"...\"}' or echo '{...}' | execute.sh"
+print_usage() {
+  cat <<'EOF_USAGE'
+Usage:
+  # CLI flags (preferred — avoids shell escaping issues)
+  bash execute.sh --session dev-1 --status done --summary "Fixed the bug" --project /path/to/project
 
-SESSION_NAME=$(printf '%s' "$INPUT" | jq -r '.sessionName // empty')
-STATUS=$(printf '%s' "$INPUT" | jq -r '.status // empty')
-SUMMARY=$(printf '%s' "$INPUT" | jq -r '.summary // empty')
-TASK_PATH=$(printf '%s' "$INPUT" | jq -r '.taskPath // empty')
-require_param "sessionName" "$SESSION_NAME"
-require_param "status" "$STATUS"
-require_param "summary" "$SUMMARY"
+  # Summary from stdin (for multi-line or special characters)
+  echo "Fixed the bug — it's working" | bash execute.sh --session dev-1 --status done --project /path
 
-# Optional structured StatusReport fields (for hierarchical workflows)
-TASK_ID=$(printf '%s' "$INPUT" | jq -r '.taskId // empty')
-PROGRESS=$(printf '%s' "$INPUT" | jq -r '.progress // empty')
-ARTIFACTS=$(printf '%s' "$INPUT" | jq -c '.artifacts // empty')
-BLOCKERS=$(printf '%s' "$INPUT" | jq -c '.blockers // empty')
-USE_STRUCTURED=$(printf '%s' "$INPUT" | jq -r '.structured // "false"')
+  # Summary from file
+  bash execute.sh --session dev-1 --status done --summary-file /tmp/summary.txt --project /path
+
+  # Legacy JSON argument (backward compatible)
+  bash execute.sh '{"sessionName":"dev-1","status":"done","summary":"Fixed the bug"}'
+
+Options:
+  --session  | -s   Agent session name (required)
+  --status   | -S   Status: done, blocked, failed, in_progress, active (required)
+  --summary  | -m   Status summary text (required unless piped via stdin)
+  --summary-file    Read summary from file path
+  --project  | -p   Project path for auto-remember on completion
+  --task-path       Task file path to auto-complete
+  --task-id         Task ID (for structured StatusReport format)
+  --progress        Progress percentage (0-100, for structured format)
+  --structured      Use structured StatusReport format (true/false)
+  --json     | -j   Raw JSON payload (same as legacy)
+  --help     | -h   Show this help
+EOF_USAGE
+}
+
+INPUT_JSON=""
+SESSION_NAME=""
+STATUS=""
+SUMMARY=""
+PROJECT_PATH=""
+TASK_PATH=""
+TASK_ID=""
+PROGRESS=""
+STRUCTURED="false"
+
+# Detect legacy JSON argument as the first parameter
+if [[ $# -gt 0 && ${1:0:1} == '{' ]]; then
+  INPUT_JSON="$1"
+  shift || true
+fi
+
+while [[ $# -gt 0 ]]; do
+  case "$1" in
+    --session|-s)
+      SESSION_NAME="$2"
+      shift 2
+      ;;
+    --status|-S)
+      STATUS="$2"
+      shift 2
+      ;;
+    --summary|-m)
+      SUMMARY="$2"
+      shift 2
+      ;;
+    --summary-file)
+      SUMMARY="$(cat "$2")"
+      shift 2
+      ;;
+    --project|-p)
+      PROJECT_PATH="$2"
+      shift 2
+      ;;
+    --task-path)
+      TASK_PATH="$2"
+      shift 2
+      ;;
+    --task-id)
+      TASK_ID="$2"
+      shift 2
+      ;;
+    --progress)
+      PROGRESS="$2"
+      shift 2
+      ;;
+    --structured)
+      STRUCTURED="true"
+      shift
+      ;;
+    --json|-j)
+      INPUT_JSON="$2"
+      shift 2
+      ;;
+    --help|-h)
+      print_usage
+      exit 0
+      ;;
+    --)
+      shift
+      break
+      ;;
+    *)
+      if [[ -z "$INPUT_JSON" && ${1:0:1} == '{' ]]; then
+        INPUT_JSON="$1"
+        shift
+      else
+        error_exit "Unknown argument: $1. Use --help for usage."
+      fi
+      ;;
+  esac
+done
+
+# If nothing provided yet but stdin has data, read it as summary
+if [ -z "$INPUT_JSON" ] && [ -z "$SUMMARY" ] && [ ! -t 0 ]; then
+  STDIN_DATA="$(cat)"
+  if [[ ${STDIN_DATA:0:1} == '{' ]]; then
+    INPUT_JSON="$STDIN_DATA"
+  else
+    SUMMARY="$STDIN_DATA"
+  fi
+fi
+
+# Parse JSON input if provided (backward compatible)
+if [ -n "$INPUT_JSON" ]; then
+  INPUT=$(read_json_input "$INPUT_JSON")
+  [ -z "$SESSION_NAME" ] && SESSION_NAME=$(printf '%s' "$INPUT" | jq -r '.sessionName // empty')
+  [ -z "$STATUS" ] && STATUS=$(printf '%s' "$INPUT" | jq -r '.status // empty')
+  [ -z "$SUMMARY" ] && SUMMARY=$(printf '%s' "$INPUT" | jq -r '.summary // empty')
+  [ -z "$TASK_PATH" ] && TASK_PATH=$(printf '%s' "$INPUT" | jq -r '.taskPath // empty')
+  [ -z "$TASK_ID" ] && TASK_ID=$(printf '%s' "$INPUT" | jq -r '.taskId // empty')
+  [ -z "$PROGRESS" ] && PROGRESS=$(printf '%s' "$INPUT" | jq -r '.progress // empty')
+  [ -z "$PROJECT_PATH" ] && PROJECT_PATH=$(printf '%s' "$INPUT" | jq -r '.projectPath // empty')
+  ARTIFACTS=$(printf '%s' "$INPUT" | jq -c '.artifacts // empty')
+  BLOCKERS=$(printf '%s' "$INPUT" | jq -c '.blockers // empty')
+  USE_STRUCTURED=$(printf '%s' "$INPUT" | jq -r '.structured // "false"')
+  [ "$USE_STRUCTURED" = "true" ] && STRUCTURED="true"
+else
+  ARTIFACTS=""
+  BLOCKERS=""
+fi
+
+require_param "sessionName (--session)" "$SESSION_NAME"
+require_param "status (--status)" "$STATUS"
+require_param "summary (--summary)" "$SUMMARY"
 
 # Map simple status strings to InProgressTaskStatus values
 map_status_to_state() {
@@ -34,7 +157,7 @@ map_status_to_state() {
 }
 
 # Build the message the orchestrator will receive
-if [ "$USE_STRUCTURED" = "true" ] && [ -n "$TASK_ID" ]; then
+if [ "$STRUCTURED" = "true" ] && [ -n "$TASK_ID" ]; then
   # Structured StatusReport format for hierarchical teams
   STATE=$(map_status_to_state "$STATUS")
   MESSAGE="---\n[STATUS REPORT]\nTask ID: ${TASK_ID}\nState: ${STATE}"
@@ -68,12 +191,6 @@ BODY=$(jq -n --arg content "$MESSAGE" --arg senderName "$SESSION_NAME" \
 
 api_call POST "/chat/agent-response" "$BODY"
 
-# Auto-register as active when reporting "active" or first status.
-# This ensures the agent's agentStatus transitions from "started" to "active"
-# in storage, which the queue processor requires before delivering messages.
-# Without this, agents that call report-status instead of register-self
-# remain stuck in "started" state indefinitely.
-
 # If task is done and taskPath provided, move task file to done folder
 if [ "$STATUS" = "done" ] && [ -n "$TASK_PATH" ]; then
   COMPLETE_BODY=$(jq -n \
@@ -90,9 +207,6 @@ if [ "$STATUS" = "done" ]; then
 fi
 
 # Auto-persist key findings as project knowledge when task is done (#127, #219).
-# Use [COMPLETED] prefix so recall can distinguish completed tasks from other patterns.
-# This prevents PM from re-delegating tasks that were already done.
 if [ "$STATUS" = "done" ] && [ -n "$SUMMARY" ]; then
-  PROJECT_PATH=$(printf '%s' "$INPUT" | jq -r '.projectPath // empty')
   auto_remember "$SESSION_NAME" "[COMPLETED] Task completed by ${SESSION_NAME}: ${SUMMARY}" "decision" "project" "$PROJECT_PATH"
 fi