juno-code 1.0.44 → 1.0.46

package/dist/templates/scripts/slack_fetch.py

@@ -11,18 +11,22 @@ Features:
 - Default --once mode for cron/scheduled jobs
 - Persistent state tracking (no duplicate processing)
 - Automatic kanban task creation with slack-input tag
+- File attachment downloading (saves to .juno_task/attachments/slack/)
 - Graceful shutdown on SIGINT/SIGTERM
 
 Usage:
     python slack_fetch.py --channel bug-reports --once
     python slack_fetch.py --channel feature-requests --continuous
     python slack_fetch.py --channel general --dry-run --verbose
+    python slack_fetch.py --channel uploads --download-attachments
 
 Environment Variables:
-    SLACK_BOT_TOKEN         Slack bot token (required, starts with xoxb-)
-    SLACK_CHANNEL           Default channel to monitor
-    CHECK_INTERVAL_SECONDS  Polling interval in seconds (default: 60)
-    LOG_LEVEL               DEBUG, INFO, WARNING, ERROR (default: INFO)
+    SLACK_BOT_TOKEN             Slack bot token (required, starts with xoxb-)
+    SLACK_CHANNEL               Default channel to monitor
+    CHECK_INTERVAL_SECONDS      Polling interval in seconds (default: 60)
+    LOG_LEVEL                   DEBUG, INFO, WARNING, ERROR (default: INFO)
+    JUNO_DOWNLOAD_ATTACHMENTS   Enable/disable file downloads (default: true)
+    JUNO_MAX_ATTACHMENT_SIZE    Max file size in bytes (default: 50MB)
 """
 
 import argparse
@@ -35,7 +39,7 @@ import sys
 import time
 from datetime import datetime
 from pathlib import Path
-from typing import Dict, List, Optional, Any
+from typing import Dict, List, Optional, Any, Tuple
 
 try:
     from dotenv import load_dotenv
@@ -46,15 +50,32 @@ except ImportError as e:
     print("Please run: pip install slack_sdk python-dotenv")
     sys.exit(1)
 
-# Import local state manager
+# Import local modules
+script_dir = Path(__file__).parent
+sys.path.insert(0, str(script_dir))
+
 try:
     from slack_state import SlackStateManager
 except ImportError:
     # Fallback: try importing from same directory
-    script_dir = Path(__file__).parent
-    sys.path.insert(0, str(script_dir))
     from slack_state import SlackStateManager
 
+# Import attachment downloader for file handling
+try:
+    from attachment_downloader import (
+        AttachmentDownloader,
+        format_attachments_section,
+        is_attachments_enabled
+    )
+    ATTACHMENTS_AVAILABLE = True
+except ImportError:
+    ATTACHMENTS_AVAILABLE = False
+    # Define stub functions if attachment_downloader not available
+    def is_attachments_enabled():
+        return False
+    def format_attachments_section(paths):
+        return ""
+
 
 # Global shutdown flag
 shutdown_requested = False
@@ -235,6 +256,119 @@ def sanitize_tag(tag: str) -> str:
     return tag
 
 
+# =============================================================================
+# File Attachment Handling
+# =============================================================================
+
+def extract_files_from_message(message: Dict[str, Any]) -> List[Dict[str, Any]]:
+    """
+    Extract file attachment information from a Slack message.
+
+    Args:
+        message: Message dict from conversations.history API
+
+    Returns:
+        List of file info dicts with keys: id, name, url_private_download, size, mimetype
+    """
+    files = message.get('files', [])
+    if not files:
+        return []
+
+    extracted = []
+    for file_info in files:
+        # Skip external file links (not uploaded to Slack)
+        if file_info.get('mode') == 'external':
+            logger.debug(f"Skipping external file: {file_info.get('name')}")
+            continue
+
+        # Skip files that are tombstoned (deleted)
+        if file_info.get('mode') == 'tombstone':
+            logger.debug(f"Skipping deleted file: {file_info.get('id')}")
+            continue
+
+        extracted.append({
+            'id': file_info.get('id'),
+            'name': file_info.get('name', f"file_{file_info.get('id')}"),
+            'url_private_download': file_info.get('url_private_download'),
+            'url_private': file_info.get('url_private'),
+            'size': file_info.get('size', 0),
+            'mimetype': file_info.get('mimetype', 'application/octet-stream'),
+            'filetype': file_info.get('filetype', 'unknown'),
+            'title': file_info.get('title', '')
+        })
+
+    return extracted
+
+
+def download_message_files(
+    files: List[Dict[str, Any]],
+    bot_token: str,
+    channel_id: str,
+    message_ts: str,
+    downloader: 'AttachmentDownloader'
+) -> List[str]:
+    """
+    Download all files from a Slack message.
+
+    Args:
+        files: List of file info dicts from extract_files_from_message()
+        bot_token: Slack bot token for authorization
+        channel_id: Channel ID for directory organization
+        message_ts: Message timestamp for filename prefix
+        downloader: AttachmentDownloader instance
+
+    Returns:
+        List of local file paths (empty for failures)
+    """
+    if not files:
+        return []
+
+    downloaded_paths = []
+    headers = {'Authorization': f'Bearer {bot_token}'}
+
+    # Sanitize message_ts for use in filename (remove dots)
+    ts_prefix = message_ts.replace('.', '_')
+
+    target_dir = downloader.base_dir / 'slack' / channel_id
+
+    for file_info in files:
+        # Prefer url_private_download, fallback to url_private
+        url = file_info.get('url_private_download') or file_info.get('url_private')
+        if not url:
+            logger.warning(f"No download URL for file {file_info.get('id')}")
+            continue
+
+        original_filename = file_info.get('name', 'unnamed')
+
+        metadata = {
+            'source': 'slack',
+            'source_id': file_info.get('id'),
+            'message_ts': message_ts,
+            'channel_id': channel_id,
+            'mime_type': file_info.get('mimetype'),
+            'filetype': file_info.get('filetype'),
+            'title': file_info.get('title', ''),
+            'original_size': file_info.get('size', 0)
+        }
+
+        path, error = downloader.download_file(
+            url=url,
+            target_dir=target_dir,
+            filename_prefix=ts_prefix,
+            original_filename=original_filename,
+            headers=headers,
+            metadata=metadata
+        )
+
+        if path:
+            downloaded_paths.append(path)
+            logger.info(f"Downloaded Slack file: {original_filename}")
+        else:
+            logger.warning(f"Failed to download {original_filename}: {error}")
+
+    return downloaded_paths
+
+
 def create_kanban_task(
     message_text: str,
     author_name: str,
@@ -310,7 +444,10 @@ def process_messages(
     client: WebClient,
     state_mgr: SlackStateManager,
     kanban_script: str,
-    dry_run: bool = False
+    dry_run: bool = False,
+    bot_token: Optional[str] = None,
+    downloader: Optional['AttachmentDownloader'] = None,
+    download_attachments: bool = True
 ) -> int:
     """
     Process new messages: create kanban tasks and update state.
@@ -323,6 +460,9 @@ def process_messages(
         state_mgr: SlackStateManager instance
         kanban_script: Path to kanban.sh script
         dry_run: If True, don't create tasks
+        bot_token: Slack bot token for downloading attachments
+        downloader: AttachmentDownloader instance for file downloads
+        download_attachments: Whether to download file attachments
 
     Returns:
         Number of messages processed
@@ -341,8 +481,11 @@ def process_messages(
         user_id = msg.get('user', 'unknown')
         text = msg.get('text', '')
 
-        # Skip empty messages
-        if not text.strip():
+        # Check if message has files (allows processing messages with only attachments)
+        has_files = bool(msg.get('files'))
+
+        # Skip empty messages (unless they have files)
+        if not text.strip() and not has_files:
             logger.debug(f"Skipping empty message ts={ts}")
             continue
 
@@ -362,11 +505,40 @@ def process_messages(
 
         logger.info(f"New message from {author_name}: {text[:50]}{'...' if len(text) > 50 else ''}")
 
+        # Handle file attachments
+        attachment_paths = []
+        if download_attachments and ATTACHMENTS_AVAILABLE and downloader and bot_token:
+            files = extract_files_from_message(msg)
+            if files:
+                logger.info(f"Found {len(files)} file(s) attached to message")
+                if not dry_run:
+                    attachment_paths = download_message_files(
+                        files=files,
+                        bot_token=bot_token,
+                        channel_id=channel_id,
+                        message_ts=ts,
+                        downloader=downloader
+                    )
+                    if attachment_paths:
+                        logger.info(f"Downloaded {len(attachment_paths)} file(s)")
+                else:
+                    logger.info(f"[DRY RUN] Would download {len(files)} file(s)")
+
+        # Build task text with attachment paths
+        task_text = text
+        if attachment_paths:
+            task_text += format_attachments_section(attachment_paths)
+
         # Create kanban task
         # Create author tag with sanitization (colons not allowed in kanban tags)
         author_tag = sanitize_tag(f'author_{author_name}')
         tags = ['slack-input', author_tag]
-        task_id = create_kanban_task(text, author_name, tags, kanban_script, dry_run)
+
+        # Add has-attachments tag if files were downloaded
+        if attachment_paths:
+            tags.append('has-attachments')
+
+        task_id = create_kanban_task(task_text, author_name, tags, kanban_script, dry_run)
 
         if task_id:
             # Record in state
@@ -377,7 +549,9 @@ def process_messages(
                 'date': date_str,
                 'channel': channel_name,
                 'channel_id': channel_id,
-                'thread_ts': msg.get('thread_ts', ts)
+                'thread_ts': msg.get('thread_ts', ts),
+                'attachment_count': len(attachment_paths),
+                'attachment_paths': attachment_paths
             }
 
             if not dry_run:
@@ -408,7 +582,7 @@ def find_kanban_script(project_dir: Path) -> Optional[str]:
 SLACK_TOKEN_DOCS_URL = "https://api.slack.com/tutorials/tracks/getting-a-token"
 
 
-def validate_slack_environment() -> tuple[Optional[str], Optional[str], list[str]]:
+def validate_slack_environment() -> Tuple[Optional[str], Optional[str], List[str]]:
     """
     Validate Slack environment variables are properly configured.
 
@@ -486,6 +660,7 @@ Generating a Slack Bot Token:
      - channels:history, channels:read (public channels)
      - groups:history, groups:read (private channels)
      - users:read (user info)
+     - files:read (download file attachments)
      - chat:write (for slack_respond.py)
   3. Install the app to your workspace
   4. Copy the "Bot User OAuth Token" (starts with xoxb-)
@@ -583,9 +758,21 @@ def main_loop(args: argparse.Namespace) -> int:
     if args.dry_run:
         logger.info("Running in DRY RUN mode - no tasks will be created")
 
+    # Initialize attachment downloader if enabled
+    downloader = None
+    download_attachments = getattr(args, 'download_attachments', True) and is_attachments_enabled()
+    if download_attachments and ATTACHMENTS_AVAILABLE:
+        attachments_dir = project_dir / '.juno_task' / 'attachments'
+        downloader = AttachmentDownloader(base_dir=str(attachments_dir))
+        logger.info(f"Attachment downloads enabled: {attachments_dir}")
+    elif download_attachments and not ATTACHMENTS_AVAILABLE:
+        logger.warning("Attachment downloads requested but attachment_downloader module not available")
+        download_attachments = False
+
     logger.info(f"Monitoring channel #{channel} (ID: {channel_id})")
     logger.info(f"Check interval: {check_interval} seconds")
     logger.info(f"Mode: {'once' if args.once else 'continuous'}")
+    logger.info(f"Download attachments: {download_attachments}")
     logger.info("-" * 70)
 
     # Main loop
@@ -614,7 +801,10 @@ def main_loop(args: argparse.Namespace) -> int:
                     client,
                     state_mgr,
                     kanban_script,
-                    dry_run=args.dry_run
+                    dry_run=args.dry_run,
+                    bot_token=bot_token,
+                    downloader=downloader,
+                    download_attachments=download_attachments
                 )
                 total_processed += processed
                 logger.info(f"Processed {processed} messages (total: {total_processed})")
@@ -655,20 +845,26 @@ def main() -> int:
         formatter_class=argparse.RawDescriptionHelpFormatter,
         epilog="""
 Examples:
-  %(prog)s --channel bug-reports                # Run once (default)
+  %(prog)s --channel bug-reports                    # Run once (default)
   %(prog)s --channel feature-requests --continuous  # Continuous monitoring
   %(prog)s --channel general --dry-run --verbose    # Test mode
+  %(prog)s --channel uploads --download-attachments # Explicit attachment download
 
 Environment Variables:
-  SLACK_BOT_TOKEN          Slack bot token (required)
-  SLACK_CHANNEL            Default channel to monitor
-  CHECK_INTERVAL_SECONDS   Polling interval (default: 60)
-  LOG_LEVEL               DEBUG, INFO, WARNING, ERROR (default: INFO)
+  SLACK_BOT_TOKEN              Slack bot token (required)
+  SLACK_CHANNEL                Default channel to monitor
+  CHECK_INTERVAL_SECONDS       Polling interval (default: 60)
+  LOG_LEVEL                    DEBUG, INFO, WARNING, ERROR (default: INFO)
+  JUNO_DOWNLOAD_ATTACHMENTS    Enable/disable file downloads (default: true)
+  JUNO_MAX_ATTACHMENT_SIZE     Max file size in bytes (default: 50MB)
 
 Notes:
   - Messages are tagged with 'slack-input' and 'author_<name>'
+  - Messages with attachments also get 'has-attachments' tag
   - State is persisted to .juno_task/slack/slack.ndjson
+  - Attachments saved to .juno_task/attachments/slack/<channel_id>/
   - Use Ctrl+C for graceful shutdown
+  - Required OAuth scope for file downloads: files:read
         """
     )
 
@@ -692,6 +888,22 @@ Notes:
         help='Run continuously with polling'
     )
 
+    # Attachment handling options
+    attachment_group = parser.add_mutually_exclusive_group()
+    attachment_group.add_argument(
+        '--download-attachments',
+        dest='download_attachments',
+        action='store_true',
+        default=True,
+        help='Download file attachments from messages (DEFAULT)'
+    )
+    attachment_group.add_argument(
+        '--no-attachments',
+        dest='download_attachments',
+        action='store_false',
+        help='Skip downloading file attachments'
+    )
+
     parser.add_argument(
         '--dry-run',
         action='store_true',

package/dist/templates/services/claude.py

@@ -27,10 +27,11 @@ class ClaudeService:
         ":claude-haiku-4-5": "claude-haiku-4-5-20251001",
         ":claude-sonnet-4-5": "claude-sonnet-4-5-20250929",
         ":claude-opus-4-5": "claude-opus-4-5-20251101",
+        ":claude-opus-4-6": "claude-opus-4-6",
         ":claude-opus-4": "claude-opus-4-20250514",
         ":haiku": "claude-haiku-4-5-20251001",
         ":sonnet": "claude-sonnet-4-5-20250929",
-        ":opus": "claude-opus-4-5-20251101",
+        ":opus": "claude-opus-4-6",
     }
 
     # Default allowed tools (used with --append-allowed-tools)
@@ -388,6 +389,54 @@ Environment Variables:
                     simplified["content"] = text_content
                     return json.dumps(simplified, ensure_ascii=False)
 
+            # For progress events, handle bash_progress and skip hook_progress
+            elif data.get("type") == "progress":
+                progress_data = data.get("data", {})
+                progress_type = progress_data.get("type", "")
+
+                # Skip hook_progress events (not interested)
+                if progress_type == "hook_progress":
+                    return None
+
+                # Display bash_progress events with [Progress] tag
+                if progress_type == "bash_progress":
+                    # Extract relevant fields from bash_progress
+                    output_text = progress_data.get("output", "")
+                    elapsed_time = progress_data.get("elapsedTimeSeconds", 0)
+                    total_lines = progress_data.get("totalLines", 0)
+
+                    # Create simplified output with datetime and counter
+                    simplified = {
+                        "type": "progress",
+                        "progress_type": "bash_progress",
+                        "datetime": now,
+                        "counter": f"#{self.message_counter}",
+                        "elapsed": f"{elapsed_time}s",
+                        "lines": total_lines
+                    }
+
+                    # Check if output has newlines
+                    if '\n' in output_text:
+                        # Multi-line output: print metadata, then raw output
+                        metadata_json = json.dumps(simplified, ensure_ascii=False)
+                        return metadata_json + "\n[Progress] output:\n" + output_text
+                    else:
+                        # Single-line output: normal JSON with [Progress] tag
+                        simplified["output"] = output_text
+                        # Add [Progress] tag to the output
+                        output_json = json.dumps(simplified, ensure_ascii=False)
+                        return f"[Progress] {output_json}"
+
+                # For other progress types, display with datetime and counter
+                simplified = {
+                    "type": "progress",
+                    "progress_type": progress_type,
+                    "datetime": now,
+                    "counter": f"#{self.message_counter}",
+                    "data": progress_data
+                }
+                return json.dumps(simplified, ensure_ascii=False)
+
             # For assistant messages, show simplified output
             elif data.get("type") == "assistant":
                 message = data.get("message", {})

package/dist/templates/services/codex.py

@@ -17,12 +17,13 @@ class CodexService:
     """Service wrapper for OpenAI Codex CLI"""
 
     # Default configuration
-    DEFAULT_MODEL = "codex-5.2-max"
+    DEFAULT_MODEL = "gpt-5.3-codex"
     DEFAULT_AUTO_INSTRUCTION = """You are an AI coding assistant. Follow the instructions provided and generate high-quality code."""
 
     # Model shorthand mappings (colon-prefixed names expand to full model IDs)
     MODEL_SHORTHANDS = {
-        ":codex": "codex-5.2-codex-max",
+        ":codex": "gpt-5.3-codex",
+        ":codex-mini": "gpt-5.1-codex-mini",
         ":gpt-5": "gpt-5",
         ":mini": "gpt-5-codex-mini",
     }
@@ -70,10 +71,10 @@ Examples:
   %(prog)s -p "Write a hello world function"
   %(prog)s -pp prompt.txt --cd /path/to/project
   %(prog)s -p "Add tests" -m gpt-4 -c custom_arg=value
-  %(prog)s -p "Optimize code" -m :codex  # uses codex-5.2-codex-max
+  %(prog)s -p "Optimize code" -m :codex  # uses gpt-5.3-codex
 
 Environment Variables:
-  CODEX_MODEL                Model name (supports shorthand, default: codex-5.2-max)
+  CODEX_MODEL                Model name (supports shorthand, default: gpt-5.3-codex)
   CODEX_HIDE_STREAM_TYPES    Comma-separated list of streaming msg types to hide
                              Default: turn_diff,token_count,exec_command_output_delta
   JUNO_CODE_HIDE_STREAM_TYPES Same as CODEX_HIDE_STREAM_TYPES (alias)

package/dist/templates/skills/claude/plan-kanban-tasks/SKILL.md

@@ -0,0 +1,25 @@
+---
+name: plan-kanban-tasks
+description: Generate Product Development Requirments(PDR) and create task on kanban. Use when user explictly ask for, or ask for creating a task, planing a feature, register a task on kaban.
+argument-hint: [Required Features] [Constraints] [Specification] [Test Criteria]
+---
+
+First task is to study @.juno_task/plan.md  (it may be incorrect) 
+and study what is needed to achieve the main task.
+
+
+Second Task is to understand the task, create a spec for process to follow, plan to execute, scripts to create, virtual enviroment that we need, things that we need to be aware of, how to test the scripts and follow progress.
+Think hard and plan/create spec for every step of this task
+and for each part create a seperate .md file under @.juno_task/specs/*
+
+## Task 2
+Update @.juno_task/plan.md with the new specs and Requirments.
+
+## Part 3 
+
+Create PDR on kanban, kanban is available in @.juno_task/scripts/kanban.sh 
+In the task body, include requirments, success criteria, test scenarios and jobs to be done. 
+For each chunk of the required feature create a seperate task, we want tasks, small enough to be done in one iteration, without compacting context window.
+
+
+

package/dist/templates/skills/claude/ralph-loop/SKILL.md

@@ -0,0 +1,43 @@
+---
+name: ralph-loop
+description: should only get executed with explicit user request.
+---
+0a. study [references/implement.md](references/implement.md).
+
+0b.  When you discover a syntax, logic, UI, User Flow Error or bug. Immediately update  tasks.md with your findings using a  subagent. When the issue is resolved, update tasks.md and remove the item using a  subagent.
+
+
+999. Important: When authoring documentation capture the why tests and the backing implementation is important.
+
+9999. Important: We want single sources of truth, no migrations/adapters. If tests unrelated to your work fail then it's your job to resolve these tests as part of the increment of change.
+
+999999. As soon as there are no build or test errors create a git tag. If there are no git tags start at 0.0.0 and increment patch by 1 for example 0.0.1 if 0.0.0 does not exist.
+
+999999999. You may add extra logging if required to be able to debug the issues.
+
+9999999999. ALWAYS KEEP Tasks up to date with your learnings using a  subagent. Especially after wrapping up/finishing your turn.
+
+
+
+99999999999. When you learn something new about how to run the app or examples make sure you update @Claude.md using a  subagent but keep it brief. For example if you run commands multiple times before learning the correct command then that file should be updated.
+
+999999999999. IMPORTANT when you discover a bug resolve it using  subagents even if it is unrelated to the current piece of work after documenting it in Tasks
+
+9999999999999999999. Keep @Claude.md up to date with information on how to build the app and your learnings to optimize the build/test loop using a  subagent.
+
+999999999999999999999. For any bugs you notice, it's important to resolve them or document them in Tasks to be resolved using a  subagent.
+
+99999999999999999999999. When authoring the missing features you may author multiple standard libraries at once using up to 1000 parallel subagents
+
+99999999999999999999999999. When Tasks, Claude.md becomes large periodically clean out the items that are completed from the file using a  subagent.
+Large Claude.md reduce the performance.
+
+
+
+9999999999999999999999999999. DO NOT IMPLEMENT PLACEHOLDER OR SIMPLE IMPLEMENTATIONS. WE WANT FULL IMPLEMENTATIONS. DO IT OR I WILL YELL AT YOU
+
+9999999999999999999999999999999. SUPER IMPORTANT DO NOT IGNORE. DO NOT PLACE STATUS REPORT UPDATES INTO @Claude.md
+
+99999999999999999999999999999999. After reveiwing Feedback, if you find an open issue, you need to update previously handled issues status as well. If user reporting a bug, that earlier on reported on the Tasks or @Claude.md as resolved. You should update it to reflect that the issue is not resolved.
+it would be ok to include past reasoning and root causing to the open issue, You should mention. <PREVIOUS_AGENT_ATTEMP> Tag and describe the approach already taken, so the agent knows 1.the issue is still open,2. past approaches to resolve it, what it was, and know that it has failed.
+Tasks , USER_FEEDBACK and @Claude.md should repesent truth. User Open Issue is a high level of truth. so you need to reflect it on the files.

package/dist/templates/skills/claude/ralph-loop/references/first_check.md

@@ -0,0 +1,20 @@
+### Check once
+
+Perform these check once, to make sure about the git logic. There is no need to keep running this on every execution.
+
+**Detection & Creation Logic**:
+   - Check if the following command succeeds to determine if the repository is a git repo (create/verify .gitignore if so):
+
+     ```sh
+     git rev-parse --git-dir 2>/dev/null
+     ```
+   - Check if Dockerfile* exists or Docker in plan.md → create/verify .dockerignore
+   - Check if .eslintrc* or eslint.config.* exists → create/verify .eslintignore
+   - Check if .prettierrc* exists → create/verify .prettierignore
+   - Check if .npmrc or package.json exists → create/verify .npmignore (if publishing)
+   - Check if terraform files (*.tf) exist → create/verify .terraformignore
+   - Check if .helmignore needed (helm charts present) → create/verify .helmignore
+   
+   **If ignore file already exists**: Verify it contains essential patterns, append missing critical patterns only
+   **If ignore file missing**: Create with full pattern set for detected technology
+   

package/dist/templates/skills/claude/ralph-loop/references/implement.md

@@ -0,0 +1,99 @@
+---
+description: Study kanban.sh and Execute the implementation plan by processing and executing all tasks defined in  ./juno_task/tasks.md, update ./juno_task/tasks.md with the tasks on kanban
+---
+
+## User Input
+```text
+A.
+**ALWAYS check remaing tasks and user feedbacks. Integrate it into the plan,
+this is the primary mechanism for user input and for you to track your progress.
+`./juno_task/scripts/kanban.sh list --limit 5`
+return the most recent 5 Tasks and their status and potential agent response to them.
+
+**Important** ./juno_task/scripts/kanban.sh has already installed in your enviroment and you can execute it in your bash.
+
+A-1.
+read @.juno_task/USER_FEEDBACK.md user feedback on your current execution will be writeen here. And will guide you. If user wants to talk to you while you are working , he will write into this file. first think you do is to read it file.
+
+B.
+Based on Items in **./juno_task/scripts/kanban.sh** reflect on @.juno_task/plan.md and keep it up-to-date.
+0g. Entities and their status in **./juno_task/scripts/kanban.sh** has higher priority and level of truth than other parts of the app.
+If you see user report a bug that you earlier marked as resolved, you need to investigate the issue again.
+./juno_task/scripts/kanban.sh items has the higher level of truth. Always
+
+0e. Status in ./juno_task/scripts/kanban.sh could be backlog, todo, in_progress, done.
+in_progress, todo, backlog. That is the priority of tasks in general sense, unless you find something with 10X magnitute of importance, or if you do it first it make other tasks easier or unnecessary.
+
+
+0f. After reviwing Feedback, if you find an open issue, you need to update previously handled issues status as well. If user reporting a bug, that earlier on reported on the feedback/plan or Claude.md as resolved. You should update it to reflect that the issue is not resolved.
+`./juno_task/scripts/kanban.sh mark todo --ID {Task_ID}`
+
+it would be ok to include past reasoning and root causing to the open issue, You should mention. <PREVIOUS_AGENT_ATTEMP> Tag and describe the approach already taken, so the agent knows
+   1.the issue is still open,
+   2. past approaches to resolve it, what it was, and know that it has failed.
+`./juno_task/scripts/kanban.sh mark todo --ID {Task_ID} --response "<PREVIOUS_AGENT_ATTEMP>{what happend before ...}<PREVIOUS_AGENT_ATTEMP>" `
+
+   **Note** updating response will REPLACE response. So you need to include everything important from the past as well you can check the content of a task with
+   `./juno_task/scripts/kanban.sh get {TASK_ID}`
+
+
+
+C. Using parallel subagents. You may use up to 500 parallel subagents for all operations but only 1 subagent for build/tests.
+
+D. Choose the most important 1 things, ( Based on Open Issue  and Also Tasks ), Think hard about what is the most important Task. 
+
+E. update status of most important task on ./juno_task/scripts/kanban.sh.
+(if the task is not on ./juno_task/scripts/kanban.sh, create it ! Kanban is our source of truth)
+`./juno_task/scripts/kanban.sh mark in_progress --ID {Task_ID}`
+
+
+F. Implement the most important 1 thing following the outline. 
+
+```
+
+You **MUST** consider the user input before proceeding (if not empty).
+
+## Outline
+  
+. Execute implementation following the task plan:
+   - **Phase-by-phase execution**: Complete each phase before moving to the next
+   - **Respect dependencies**: Run sequential tasks in order, parallel tasks [P] can run together  
+   - **Follow TDD approach**: Execute test tasks before their corresponding implementation tasks
+   - **File-based coordination**: Tasks affecting the same files must run sequentially
+   - **Validation checkpoints**: Verify each phase completion before proceeding
+
+7. Implementation execution rules:
+   - **Setup first**: Initialize project structure, dependencies, configuration
+   - **Tests before code**: If you need to write tests for contracts, entities, and integration scenarios
+   - **Core development**: Implement models, services, CLI commands, endpoints
+   - **Integration work**: Database connections, middleware, logging, external services
+   - **Polish and validation**: Unit tests, performance optimization, documentation
+
+8. Progress tracking and error handling:
+   - Report progress after each completed task
+   - Halt execution if any non-parallel task fails
+   - For parallel tasks [P], continue with successful tasks, report failed ones
+   - Provide clear error messages with context for debugging
+   - Suggest next steps if implementation cannot proceed
+   - **IMPORTANT** For completed tasks, make sure to mark the task off as [X] in the tasks file.
+   - **IMPORTANT** Keep ./juno_task/scripts/kanban.sh up-to-date
+   When the issue is resolved always update ./juno_task/scripts/kanban.sh
+   `./juno_task/scripts/kanban.sh --status {status} --ID {task_id} --response "{key actions you take, and how you did test it}"`
+
+9. Completion validation:
+   - Verify all required tasks are completed
+   - Check that implemented features match the original specification
+   - Validate that tests pass and coverage meets requirements
+   - Confirm the implementation follows the technical plan
+   - Report final status with summary of completed work
+   - When the issue is resolved always update ./juno_task/scripts/kanban.sh
+   `./juno_task/scripts/kanban.sh --mark done --ID {task_id} --response "{key actions you take, and how you did test it}"`
+
+10. Git
+
+   When the tests pass update ./juno_task/scripts/kanban.sh, then add changed code with "git add -A" via bash then do a "git commit" with a message that describes the changes you made to the code. After the commit do a "git push" to push the changes to the remote repository.
+   Use commit message as a backlog of what has achieved. So later on we would know exactly what we achieved in each commit.
+   Update the task in ./juno_task/scripts/kanban.sh with the commit hash so later on we could map each task to a specific git commit
+   `./juno_task/scripts/kanban.sh update {task_id} --commit {commit_hash}`
+
+