mini-a-web.yaml

# Author: Nuno Aguiar
help:
  text   : Mini-A web interface to interact with the Mini-A agent via HTTP. 
  expects: 
  - name     : onport
    desc     : Port to run the HTTP server on
    example  : "8888"
    mandatory: false
  - name     : verbose
    desc     : Print detailed interaction events
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : debug
    desc     : Enable debug logging
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : debugfile
    desc     : Write debug output to a file instead of screen (implies debug=true)
    example  : "/tmp/mini-a-web-debug.ndjson"
    mandatory: false
  - name     : debugch
    desc     : SLON/JSON debug channel for the main LLM
    example  : "(type: file, options: (file: '/tmp/mini-a-main-debug.ndjson'))"
    mandatory: false
  - name     : debuglcch
    desc     : SLON/JSON debug channel for the low-cost LLM
    example  : "(type: file, options: (file: '/tmp/mini-a-lc-debug.ndjson'))"
    mandatory: false
  - name     : debugvalch
    desc     : SLON/JSON debug channel for the validation LLM
    example  : "(type: file, options: (file: '/tmp/mini-a-val-debug.ndjson'))"
    mandatory: false
  - name     : showexecs
    desc     : Show executed commands in the interaction
    example  : "false"
    mandatory: false
    options  : ["true", "false"]
  - name     : usestream
    desc     : Stream LLM tokens in real-time via SSE
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : showthinking
    desc     : Surface XML-tagged thinking blocks as thought logs
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : logpromptheaders
    desc     : Log prompt headers to console (for debugging)
    example  : "origin,referer"
    mandatory: false
  - name     : memorysessionheader
    desc     : Optional HTTP header name to derive memorysessionid when usememory=true
    example  : "x-session-id"
    mandatory: false
  - name     : usehistory
    desc     : "Boolean to enable/disable history (default: false)"
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : historykeepperiod
    desc     : Delete kept history files older than this many minutes
    example  : "1440"
    mandatory: false
  - name     : historykeepcount
    desc     : Keep only the newest N kept history files
    example  : "200"
    mandatory: false
  - name     : ssequeuetimeout
    desc     : SSE queue timeout in seconds before stale stream state is purged
    example  : "120"
    mandatory: false
  - name     : useattach
    desc     : "Boolean to enable/disable file attachments (default: false)"
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : historypath
    desc     : "Path to store history files (default: .)"
    example  : "."
    mandatory: false
  - name     : historyretention
    desc     : "History retention period in seconds (default: 600)"
    example  : "600"
    mandatory: false
  - name     : historykeep
    desc     : "Boolean to keep history files (default: false)"
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : maxcontext
    desc     : "Maximum conversation tokens before Mini-A summarizes context (default: 200000)"
    example  : "200000"
    mandatory: false
  - name     : compressgoal
    desc     : "Boolean to enable/disable automatic compression of oversized goal text before execution (default: false)"
    example  : "false"
    mandatory: false
    options  : ["true", "false"]
  - name     : compressgoaltokens
    desc     : "Estimated token threshold above which goal compression is considered when compressgoal=true (default: 250)"
    example  : "400"
    mandatory: false
  - name     : compressgoalchars
    desc     : "Character threshold above which goal compression is considered when compressgoal=true (default: 1000)"
    example  : "1500"
    mandatory: false
  - name     : maxpromptchars
    desc     : "Maximum accepted prompt size in characters (default: 120000)"
    example  : "120000"
    mandatory: false
  - name     : rpm
    desc     : Requests per minute limit
    example  : "60"
    mandatory: false
  - name     : tpm
    desc     : Tokens per minute limit
    example  : "120000"
    mandatory: false
  - name     : maxsteps
    desc     : Maximum consecutive non-success steps
    example  : "50"
    mandatory: false
  - name     : earlystopthreshold
    desc     : Consecutive identical errors before early stop
    example  : "3"
    mandatory: false
  - name     : useplanning
    desc     : "Boolean to enable/disable task planning (default: false)"
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : updatefreq
    desc     : "Plan update frequency (auto, always, checkpoints, never)"
    example  : "auto"
    mandatory: false
  - name     : updateinterval
    desc     : "Steps between automatic plan updates when updatefreq=auto"
    example  : "3"
    mandatory: false
  - name     : forceupdates
    desc     : "Force plan updates even when actions fail"
    example  : "false"
    mandatory: false
    options  : ["true", "false"]
  - name     : planlog
    desc     : "Optional log file to append plan update entries"
    example  : "plan-updates.log"
    mandatory: false
  - name     : forceplanning
    desc     : Force planning even when heuristics would skip it
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : planfile
    desc     : Plan file to load or save before execution
    example  : "plan.md"
    mandatory: false
  - name     : planformat
    desc     : Plan format override (md or json)
    example  : "json"
    mandatory: false
  - name     : plancontent
    desc     : Inline plan content (JSON or Markdown) to preload
    example  : "# Plan"
    mandatory: false
  - name     : saveplannotes
    desc     : Append execution learnings to saved plan notes
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : resumefailed
    desc     : Attempt to resume the last failed goal on startup
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : usediagrams
    desc     : "Boolean to enable/disable Mermaid diagram generation (default: false)"
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : usemermaid
    desc     : Alias for usediagrams
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : usecharts
    desc     : "Boolean to enable/disable Chart.js chart generation (default: false)"
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : usemaps
    desc     : "Boolean to enable/disable Leaflet interactive map guidance (default: false)"
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : usesvg
    desc     : "Boolean to enable/disable secure raw SVG visual guidance (default: false)"
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : usevectors
    desc     : "Boolean to enable/disable infographic-focused vector guidance bundle (default: false)"
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : useascii
    desc     : "Boolean to enable/disable ASCII art sketch generation (default: false)"
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : usemath
    desc     : "Boolean to enable/disable math formula rendering guidance (default: false)"
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : knowledge
    desc     : Extra knowledge or context injected into the agent
    example  : "This repository uses OpenAF jobs."
    mandatory: false
  - name     : rules
    desc     : Custom agent rules (string, JSON or SLON)
    example  : "Always explain tradeoffs briefly."
    mandatory: false
  - name     : youare
    desc     : Override the opening agent persona line
    example  : "You are a precise release engineer."
    mandatory: false
  - name     : chatyouare
    desc     : Override the chatbot persona line when chatbotmode=true
    example  : "You are a helpful support assistant."
    mandatory: false
  - name     : homedir
    desc     : Override the home directory used to locate the .openaf-mini-a folder
    example  : "/tmp/mini-a-home"
    mandatory: false
  - name     : goalprefix
    desc     : Optional prefix automatically added to every goal
    example  : "[web] "
    mandatory: false
  - name     : libs
    desc     : Comma-separated list of additional OJob libraries to load
    example  : "@AWS/aws.js,custom.js"
    mandatory: false
  - name     : model
    desc     : Override OAF_MODEL for this web server session
    example  : "(type: openai, model: gpt-5-mini, key: '...')"
    mandatory: false
  - name     : modellc
    desc     : Override OAF_LC_MODEL for this web server session
    example  : "(type: openai, model: gpt-5-nano, key: '...')"
    mandatory: false
  - name     : modelval
    desc     : Override OAF_VAL_MODEL for this web server session
    example  : "(type: openai, model: gpt-5-mini, key: '...')"
    mandatory: false
  - name     : skillmaxautoload
    desc     : Maximum number of matching skills to auto-load into runtime context
    example  : "1"
    mandatory: false
  - name     : skillcontextchars
    desc     : Maximum characters read from each auto-loaded SKILL.md
    example  : "8000"
    mandatory: false
  - name     : skillmanifestchars
    desc     : Approximate character budget for skill descriptions in the system prompt manifest
    example  : "1536"
    mandatory: false
  - name     : modellock
    desc     : Lock model tier selection (auto, main or lc)
    example  : "lc"
    mandatory: false
  - name     : modelstrategy
    desc     : Model orchestration profile (default or advisor)
    example  : "advisor"
    mandatory: false
  - name     : advisormaxuses
    desc     : Maximum advisor consultations per run
    example  : "2"
    mandatory: false
  - name     : advisorenable
    desc     : Master toggle for advisor consultations
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : advisoronrisk
    desc     : Allow advisor consults on risk signals
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : advisoronambiguity
    desc     : Allow advisor consults on ambiguity signals
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : advisoronharddecision
    desc     : Allow advisor consults for hard-decision checkpoints
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : advisorcooldownsteps
    desc     : Minimum step distance between advisor consultations
    example  : "2"
    mandatory: false
  - name     : advisorbudgetratio
    desc     : Fraction of token budget advisor calls may consume
    example  : "0.20"
    mandatory: false
  - name     : emergencyreserve
    desc     : Reserved advisor budget fraction for high-value consults
    example  : "0.10"
    mandatory: false
  - name     : harddecision
    desc     : Hard-decision checkpoint mode (require, warn or off)
    example  : "warn"
    mandatory: false
  - name     : evidencegate
    desc     : Enable lightweight evidence gating
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : evidencegatestrictness
    desc     : Evidence gate strictness (low, medium or high)
    example  : "medium"
    mandatory: false
  - name     : lcescalatedefer
    desc     : Defer low-cost escalation by one step when confidence is high
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : lcbudget
    desc     : Max low-cost model tokens before switching permanently to main model
    example  : "50000"
    mandatory: false
  - name     : llmcomplexity
    desc     : Use the low-cost model to validate medium-complexity decisions
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : useshell
    desc     : Allow shell command execution
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : shell
    desc     : Prefix applied to every shell command
    example  : "docker exec sandbox"
    mandatory: false
  - name     : readwrite
    desc     : Allow write operations during shell commands
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : checkall
    desc     : Ask for confirmation before shell commands
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : shellbatch
    desc     : Automatically approve shell commands
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : shellprefix
    desc     : Prefix applied to each shell command
    example  : "docker exec sandbox"
    mandatory: false
  - name     : shellallow
    desc     : Comma-separated shell allow list
    example  : "curl,wget"
    mandatory: false
  - name     : shellbanextra
    desc     : Comma-separated extra banned shell commands
    example  : "rm,mkfs"
    mandatory: false
  - name     : shellallowpipes
    desc     : Allow pipes, redirections and shell control operators
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : shelltimeout
    desc     : Maximum shell command runtime in milliseconds
    example  : "120000"
    mandatory: false
  - name     : shellmaxbytes
    desc     : Maximum shell output size in characters
    example  : "12000"
    mandatory: false
  - name     : usesandbox
    desc     : Built-in shell sandbox preset (off, auto, linux, macos, windows)
    example  : "auto"
    mandatory: false
  - name     : sandboxprofile
    desc     : Optional macOS sandbox profile path
    example  : "/tmp/mini-a.sb"
    mandatory: false
  - name     : sandboxnonetwork
    desc     : Disable network inside the built-in sandbox when supported
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : mcp
    desc     : MCP connection definition (single or array) in SLON/JSON
    example  : "[(type: stdio, command: 'node', args: ['server.js'])]"
    mandatory: false
  - name     : usetools
    desc     : Register MCP tools directly on the model
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : usetoolslc
    desc     : Register MCP tools directly only on the low-cost model
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : usejsontool
    desc     : Register compatibility json tool when usetools=true
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : toolfallback
    desc     : Fallback to action mode when malformed pseudo tool calls are emitted
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : historys3bucket
    desc     : "S3 bucket to store conversation history objects"
    example  : "mini-a-history"
    mandatory: false
  - name     : historys3prefix
    desc     : "Optional S3 key prefix for history objects"
    example  : "sessions/"
    mandatory: false
  - name     : historys3url
    desc     : "Custom S3-compatible endpoint URL"
    example  : "https://s3.amazonaws.com"
    mandatory: false
  - name     : historys3accesskey
    desc     : "Access key ID for the history S3 endpoint"
    example  : "AKIA..."
    mandatory: false
  - name     : historys3secret
    desc     : "Secret key for the history S3 endpoint"
    example  : "WJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
    mandatory: false
  - name     : historys3region
    desc     : "Region for the history S3 endpoint when required"
    example  : "eu-west-1"
    mandatory: false
  - name     : historys3useversion1
    desc     : "Force the MinIO client to use the S3 API version 1 when listing objects"
    example  : "false"
    mandatory: false
    options  : ["true", "false"]
  - name     : historys3ignorecertcheck
    desc     : "Ignore TLS certificate validation for the history S3 endpoint (use with caution)"
    example  : "false"
    mandatory: false
    options  : ["true", "false"]
  - name     : mcplazy
    desc     : "Initialize MCP connections lazily on first use instead of during Init"
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : mcpdynamic
    desc     : Select MCP tools dynamically per goal
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : mcpproxy
    desc     : Aggregate all MCP connections behind a single proxy tool
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : mcpproxythreshold
    desc     : Global byte threshold for proxy auto-spill to temporary files
    example  : "4096"
    mandatory: false
  - name     : mcpproxytoon
    desc     : Serialize spilled proxy results as TOON text
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : mcpprogcall
    desc     : Start the per-session localhost bridge for programmatic MCP calls
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : mcpprogcallport
    desc     : Port for the programmatic MCP bridge (0 auto-selects)
    example  : "0"
    mandatory: false
  - name     : mcpprogcallmaxbytes
    desc     : Maximum inline JSON size before bridge results spill to /result/{id}
    example  : "4096"
    mandatory: false
  - name     : mcpprogcallresultttl
    desc     : TTL in seconds for spilled bridge results
    example  : "600"
    mandatory: false
  - name     : mcpprogcalltools
    desc     : Optional comma-separated allowlist of tools exposed by the bridge
    example  : "filesystemQuery,markdownFiles"
    mandatory: false
  - name     : mcpprogcallbatchmax
    desc     : Maximum calls accepted per bridge batch request
    example  : "10"
    mandatory: false
  - name     : toolcachettl
    desc     : "Default cache TTL in milliseconds for MCP tool results"
    example  : "600000"
    mandatory: false
  - name     : useutils
    desc     : "Register Mini Utils Tool utilities as an MCP connection automatically"
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : useskills
    desc     : Expose the skills utility tool within Mini Utils MCP; when useutils=false this registers only the skills tool
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : utilsroot
    desc     : Optional root directory used by Mini Utils Tool
    example  : "/path/to/repo"
    mandatory: false
  - name     : utilsallow
    desc     : "Comma-separated allowlist of Mini Utils Tool names to expose when useutils=true"
    example  : "filesystemQuery,markdownFiles"
    mandatory: false
  - name     : utilsdeny
    desc     : "Comma-separated denylist of Mini Utils Tool names to hide when useutils=true (applied after utilsallow)"
    example  : "systemInfo,textUtilities"
    mandatory: false
  - name     : mini-a-docs
    desc     : Point utilsroot to the Mini-A opack path so docs can be navigated directly
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : miniadocs
    desc     : Alias for mini-a-docs
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : chatbotmode
    desc     : "Run Mini-A in chatbot mode without agent planning prompts"
    example  : "false"
    mandatory: false
    options  : ["true", "false"]
  - name     : adaptiverouting
    desc     : Enable rule-based route selection via mini-a-router.js
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : routerorder
    desc     : Comma-separated preferred route order
    example  : "mcp_direct_call,mcp_proxy_path,shell_execution"
    mandatory: false
  - name     : routerallow
    desc     : Comma-separated allowlist of route types
    example  : "mcp_direct_call,mcp_proxy_path"
    mandatory: false
  - name     : routerdeny
    desc     : Comma-separated denylist of route types
    example  : "shell_execution"
    mandatory: false
  - name     : routerproxythreshold
    desc     : Payload size in bytes where proxy-style handling is preferred
    example  : "4096"
    mandatory: false
  - name     : usememory
    desc     : Enable the structured working memory subsystem
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : memoryuser
    desc     : Enable usememory and auto-configure file-backed global and session memory
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : memoryusersession
    desc     : Enable usememory and auto-configure file-backed session memory only
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : memoryscope
    desc     : Memory read scope (session, global or both)
    example  : "both"
    mandatory: false
  - name     : memorysessionid
    desc     : Session key used to namespace session memory
    example  : "research-2024"
    mandatory: false
  - name     : memorych
    desc     : SLON/JSON channel definition for global memory persistence
    example  : "(name: mini_a_global_mem, type: file, options: (file: '/tmp/mini-a-global.json'))"
    mandatory: false
  - name     : memorysessionch
    desc     : SLON/JSON channel definition for session memory persistence
    example  : "(name: mini_a_session_mem, type: file, options: (file: '/tmp/mini-a-session.json'))"
    mandatory: false
  - name     : memorymaxpersection
    desc     : Maximum memory entries kept per section
    example  : "80"
    mandatory: false
  - name     : memorymaxentries
    desc     : Maximum total memory entries
    example  : "500"
    mandatory: false
  - name     : memorycompactevery
    desc     : Compact memory every N updates
    example  : "8"
    mandatory: false
  - name     : memorydedup
    desc     : Enable memory deduplication
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : memorypromote
    desc     : Comma-separated memory sections to promote
    example  : "facts,decisions,summaries"
    mandatory: false
  - name     : memorystaledays
    desc     : Mark memory entries stale after this many days
    example  : "30"
    mandatory: false
  - name     : memoryinject
    desc     : Memory context injection mode (summary or full)
    example  : "summary"
    mandatory: false
  - name     : usewiki
    desc     : Enable the wiki knowledge base
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : wikiaccess
    desc     : Wiki access mode (ro or rw)
    example  : "rw"
    mandatory: false
  - name     : wikibackend
    desc     : Wiki backend (fs or s3)
    example  : "fs"
    mandatory: false
  - name     : wikiroot
    desc     : Root directory for the filesystem wiki backend
    example  : "/shared/wiki"
    mandatory: false
  - name     : wikibucket
    desc     : Bucket name for the S3 wiki backend
    example  : "mini-a-wiki"
    mandatory: false
  - name     : wikiprefix
    desc     : Prefix path for the S3 wiki backend
    example  : "wiki/"
    mandatory: false
  - name     : wikiurl
    desc     : S3 endpoint URL for the wiki backend
    example  : "https://s3.amazonaws.com"
    mandatory: false
  - name     : wikiaccesskey
    desc     : S3 access key for the wiki backend
    example  : "AKIA..."
    mandatory: false
  - name     : wikisecret
    desc     : S3 secret key for the wiki backend
    example  : "secret"
    mandatory: false
  - name     : wikiregion
    desc     : S3 region for the wiki backend
    example  : "eu-west-1"
    mandatory: false
  - name     : wikiuseversion1
    desc     : Use S3 signature v1 for wiki access
    example  : "false"
    mandatory: false
    options  : ["true", "false"]
  - name     : wikiignorecertcheck
    desc     : Disable TLS certificate checks for the wiki S3 backend
    example  : "false"
    mandatory: false
    options  : ["true", "false"]
  - name     : wikilintstaleddays
    desc     : Default stale-page threshold in days for wiki lint
    example  : "90"
    mandatory: false
  - name     : promptprofile
    desc     : "Prompt verbosity profile for system instructions (minimal, balanced, verbose)"
    example  : "balanced"
    mandatory: false
    options  : ["minimal", "balanced", "verbose"]
  - name     : systempromptbudget
    desc     : "Maximum system prompt size in estimated tokens before Mini-A drops low-priority sections"
    example  : "1800"
    mandatory: false
  - name     : format
    desc     : "Preferred Mini-A response format (md, json, yaml, toon or slon)"
    example  : "json"
    mandatory: false
  - name     : auditch
    desc     : "SLON/JSON definition of an audit channel for Mini-A interaction logs"
    example  : "(type: file, options: (file: '/tmp/mini-a-audit.log'))"
    mandatory: false
  - name     : toollog
    desc     : "SLON/JSON definition of a channel that records tool calls, arguments and responses"
    example  : "(type: file, options: (file: '/tmp/mini-a-tools.log'))"
    mandatory: false
  - name     : metricsch
    desc     : "SLON/JSON definition of an OpenAF channel where Mini-A metrics snapshots are recorded"
    example  : "(name: 'mini-a-metrics', type: 'mvs', options: (file: '/tmp/mini-a-metrics.db'))"
    mandatory: false
  - name     : usedelegation
    desc     : Enable sub-goal delegation to child Mini-A agents
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : usea2a
    desc     : Use A2A HTTP+JSON/REST endpoints for remote worker delegation
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : workers
    desc     : Comma-separated list of remote worker URLs
    example  : "http://worker-a:8080,http://worker-b:8080"
    mandatory: false
  - name     : maxconcurrent
    desc     : Maximum concurrent child agents when delegation is enabled
    example  : "4"
    mandatory: false
  - name     : delegationmaxdepth
    desc     : Maximum delegation nesting depth
    example  : "3"
    mandatory: false
  - name     : delegationtimeout
    desc     : Default subtask deadline in milliseconds
    example  : "300000"
    mandatory: false
  - name     : delegationmaxretries
    desc     : Default retry count for failed subtasks
    example  : "2"
    mandatory: false
  - name     : workerreg
    desc     : Port for worker dynamic registration server
    example  : "12345"
    mandatory: false
  - name     : workerregtoken
    desc     : Bearer token for worker registration endpoints
    example  : "secret"
    mandatory: false
  - name     : workerevictionttl
    desc     : Heartbeat TTL in milliseconds before dynamic worker eviction
    example  : "60000"
    mandatory: false
  - name     : workerregurl
    desc     : Comma-separated registration URL(s) used by workers in workermode
    example  : "http://main-host:12345"
    mandatory: false
  - name     : workerreginterval
    desc     : Worker heartbeat interval in milliseconds for self-registration
    example  : "30000"
    mandatory: false
  - name     : workerskills
    desc     : JSON/SLON array of worker skills exposed by workermode
    example  : "[(name: 'research')]"
    mandatory: false
  - name     : workertags
    desc     : Comma-separated tags appended to the default workermode skill
    example  : "web,analysis"
    mandatory: false
  - name     : showdelegate
    desc     : Show delegate/subtask events as separate lines
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : deepresearch
    desc     : Enable deep research mode with iterative validation
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : maxcycles
    desc     : Maximum research cycles in deep research mode
    example  : "3"
    mandatory: false
  - name     : validationgoal
    desc     : Validation criteria for deep research outcomes
    example  : "Must include benchmarks and tradeoffs"
    mandatory: false
  - name     : valgoal
    desc     : Alias for validationgoal
    example  : "Must include benchmarks and tradeoffs"
    mandatory: false
  - name     : validationthreshold
    desc     : Required validation verdict (PASS or score>=0.x)
    example  : "score>=0.8"
    mandatory: false
  - name     : persistlearnings
    desc     : Carry forward learnings between deep research cycles
    example  : "true"
    mandatory: false
    options  : ["true", "false"]
  - name     : agent
    desc     : Markdown agent profile path or inline content with YAML metadata
    example  : "agents/reviewer.md"
    mandatory: false
  - name     : agentfile
    desc     : Legacy alias for agent
    example  : "agents/reviewer.md"
    mandatory: false
  - name     : secpass
    desc     : Password used to initialize the OpenAF sBucket for model references
    example  : "secret"
    mandatory: false
  - name     : extracommands
    desc     : Comma-separated extra directories for custom slash commands
    example  : "/opt/mini-a/commands"
    mandatory: false
  - name     : extraskills
    desc     : Comma-separated extra directories for custom skills
    example  : "/opt/mini-a/skills"
    mandatory: false
  - name     : extrahooks
    desc     : Comma-separated extra directories for custom hooks
    example  : "/opt/mini-a/hooks"
    mandatory: false
include:
- oJobHTTPd.yaml

todo:
- Init
- Periodic cleanup of old sessions
- Shutdown history S3 client
- (httpdStart     ): "${onport:-8888}"
  ((mapLibs      )): true
- (httpdHealthz   ): "${onport:-8888}"
- (httpdMetrics   ): "${onport:-8888}"
- Static content
- (httpdService   ): "${onport:-8888}"
  ((uri          )): /ping
  ((execURI      )): | #js
    return ow.server.httpd.reply({ status: "ok" })

# Info about the server
- (httpdService   ): "${onport:-8888}"
  ((uri          )): /info
  ((execURI      )): | #js
    try {
      var _res = { status: "ok", usehistory: global.__usehistory, useattach: global.__useattach, historyretention: args.historyretention, showexecs: global.__showexecs, usestream: global.__usestream, showthinking: global.__showthinking, usemath: global.__usemath }
      return ow.server.httpd.reply(_res)
    } catch(e) {
      printErr(e)
      return ow.server.httpd.reply({ error: e.toString() })
    }

# Clear a session
- (httpdService   ): "${onport:-8888}"
  ((uri          )): /clear
  ((execURI      )): | #js
    try {
      var postData = jsonParse(request.files.postData)
      // postData.force - to be used from the history pane to delete a specific session
      // __useHistory - if no history is being used, always clear
      if (!global.__usehistory || postData.force) {
        log("Clearing session " + postData.uuid)
        if (isDef(global.__res[ postData.uuid ])) {
          delete global.__res[ postData.uuid ]
        }
        if (isDef(global.__conversations[ postData.uuid ])) {
          if (isFunction(global.__conversations[ postData.uuid ].clearSessionMemory)) {
            try { global.__conversations[ postData.uuid ].clearSessionMemory(postData.uuid) } catch(ignoreClearMemory) {}
          }
          delete global.__conversations[ postData.uuid ]
        }
        if (isDef(global.__lastActivity[ postData.uuid ])) {
          delete global.__lastActivity[ postData.uuid ]
        }
        if (isDef(global.__planState) && isDef(global.__planState[ postData.uuid ])) {
          delete global.__planState[ postData.uuid ]
        }
        if (global.__usehistory && !global.__historykeep) {
          log("Deleting history file for session " + postData.uuid)
          if (isFunction(global._mini_a_web_deleteHistory)) {
            global._mini_a_web_deleteHistory(postData.uuid)
          } else {
            // Fallback local cleanup
            var _hfile = global.__historypath + "/c-" + postData.uuid + ".json"
            if (io.fileExists(_hfile)) {
              io.rm(_hfile)
            }
          }
        }
      }
      return ow.server.httpd.reply({ status: "cleared" })
    } catch(e) {
      printErr(e)
      return ow.server.httpd.reply({ error: e.toString() })
    }

# Submit a prompt
- (httpdService   ): "${onport:-8888}"
  ((uri          )): /prompt
  ((execURI      )): | #js
    var _res = { error: "check server logs" }
    try {
      function __normalizePromptInput(value) {
        var text = isString(value) ? value : (isDef(value) ? String(value) : "")
        text = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n")
        text = text.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/g, "")
        var maxPromptChars = isNumber(global.__maxpromptchars) && global.__maxpromptchars > 0 ? global.__maxpromptchars : 120000
        if (text.length > maxPromptChars) {
          throw "prompt exceeds max allowed length (" + maxPromptChars + " chars)"
        }
        return text
      }
      
      // Parse POST data
      var postData = jsonParse(request.files.postData)
      postData.prompt = __normalizePromptInput(postData.prompt)
      // Validate UUID or generate a new one
      if (isDef(postData.uuid)) {
        _res.uuid = postData.uuid
      } else {
        _res.uuid = genUUID()
      }
      
      // Initialize response storage
      if (isUnDef(global.__res[_res.uuid])) {
        global.__res[ _res.uuid ] = [ ]
        global.__conversations[ _res.uuid ] = __
        global.__lastActivity[ _res.uuid ] = Date.now()
      } else {
        global.__lastActivity[ _res.uuid ] = Date.now()
      }
      
      // Prompt header logging
      if (global.__logpromptheaders.length > 0) {
        global.__logpromptheaders.forEach( h => {
          if (isDef(request.header[h])) {
            log("[" + _res.uuid + "] Prompt header " + h + ": " + request.header[h])
          }
        })
      }
      // Start Mini-A interaction in a non-blocking way
      $doV(() => {
        var uuid = _res.uuid, lma, isNewConversation = false
        if (global.__usestream && isFunction(global._mini_a_web_initSSE)) {
          global._mini_a_web_initSSE(uuid)
        }
        if (isDef(global.__planState) && isDef(global.__planState[ uuid ])) {
          delete global.__planState[ uuid ]
        }

        // If history is enabled, set the history file
        var _hfile = global.__usehistory ? global.__historypath + "/c-" + uuid + ".json" : __

        // If conversation does not exist, create it
        if (isUnDef(global.__conversations[ uuid ])) {
          isNewConversation = true
          // If history does not exist but we have history in memory, rebuild it
          if (global.__usehistory && !global._mini_a_web_historyExists(uuid) && isDef(global.__res[ uuid ]) && global.__res[ uuid ].length > 0) {
            // Try rebuilding
            var _data = []
            for (var i = 0; i < global.__res[ uuid ].length; i++) {
              var r = global.__res[ uuid ][i]
              if (r.event == "👤") {
                _data.push( { role: "user", content: r.message } )
              } else if (r.event == "🤖" || r.event == "⬅️") {
                _data.push( { role: "assistant", content: r.message } )
              } else if (r.event == "⚙️" || r.event == "🖥️") {
                _data.push( { role: "assistant", content: "[TOOL_OUTPUT] " + r.message } )
              }
            }
            if (_data.length > 0) {
              global._mini_a_web_saveFile(_hfile, { u: new Date(), c: _data })
              log("[" + uuid + "] Rebuilt history file " + _hfile)
            }
          }
      
          // Initialize MiniA
          lma = new MiniA()
          lma.setInteractionFn( (e, m) => {
            try {
              if (e == "stream") {
                if (global.__usestream && isFunction(global._mini_a_web_ssePush)) {
                  global._mini_a_web_ssePush(uuid, "stream", { message: m })
                }
                return
              }
              if (e == "planner_stream") {
                return
              }
              var _e = ""
              switch(e) {
              case "user"     : _e = "👤"; break
              case "exec"     : _e = "⚙️"; break
              case "shell"    : _e = "🖥️"; break
              case "think"    : _e = "💡"; break
              case "final"    : _e = "🏁"; break
              case "input"    : _e = "➡️"; break
              case "output"   : _e = "⬅️"; break
              case "thought"  : _e = "💭"; break
              case "think"    : _e = "💡"; break
              case "size"     : _e = "📏"; break
              case "rate"     : _e = "⏳"; break
              case "mcp"      : _e = "🤖"; break
              case "plan"     : _e = "🗺️"; break
              case "done"     : _e = "✅"; break
              case "error"    : _e = "❌"; break
              case "libs"     : _e = "📚"; break
              case "info"     : _e = "ℹ️"; break
              case "skill"    : _e = "🧩"; break
              case "load"     : _e = "📂"; break
              case "mcp"      : _e = "🤖"; break
              case "warn"     : _e = "⚠️"; break
              case "stop"     : _e = "🛑"; break
              case "error"    : _e = "❗"; break
              case "summarize": _e = "🌀"; break
              default         : _e = e
              }

              if (_e == "🗺️") {
                try {
                  if (isFunction(lma._normalizePlanItems)) {
                    var planItems = lma._normalizePlanItems(isObject(lma._agentState) ? lma._agentState.plan : __)
                    if (isArray(planItems) && planItems.length > 0) {
                      var statusIcons = {
                        pending     : { icon: "⏳", label: "pending" },
                        todo        : { icon: "⏳", label: "to do" },
                        not_started : { icon: "⏳", label: "not started" },
                        ready       : { icon: "⏳", label: "ready" },
                        in_progress : { icon: "⚙️", label: "in progress" },
                        progressing : { icon: "⚙️", label: "in progress" },
                        working     : { icon: "⚙️", label: "working" },
                        running     : { icon: "⚙️", label: "running" },
                        active      : { icon: "⚙️", label: "active" },
                        done        : { icon: "✅", label: "done" },
                        complete    : { icon: "✅", label: "complete" },
                        completed   : { icon: "✅", label: "completed" },
                        finished    : { icon: "✅", label: "finished" },
                        success     : { icon: "✅", label: "success" },
                        blocked     : { icon: "🛑", label: "blocked" },
                        stuck       : { icon: "🛑", label: "stuck" },
                        paused      : { icon: "⏸️", label: "paused" },
                        waiting     : { icon: "⏳", label: "waiting" },
                        failed      : { icon: "❌", label: "failed" },
                        cancelled   : { icon: "🚫", label: "cancelled" },
                        canceled    : { icon: "🚫", label: "cancelled" }
                      }
                      var doneStatuses = {
                        done: true,
                        complete: true,
                        completed: true,
                        finished: true,
                        success: true
                      }
                      var normalized = []
                      for (var i = 0; i < planItems.length; i++) {
                        var entry = planItems[i] || {}
                        var statusKey = (entry.status || entry.rawStatus || "").toString()
                        var statusInfo = statusIcons[statusKey] || { icon: "•", label: statusKey || "pending" }
                        var isDone = doneStatuses[statusKey] === true || statusInfo.icon == "✅"
                        normalized.push({
                          title   : entry.title || ("Step " + (i + 1)),
                          status  : statusKey,
                          icon    : statusInfo.icon,
                          label   : statusInfo.label,
                          done    : isDone === true,
                          rawStatus: entry.rawStatus
                        })
                      }
                      var completedCount = 0
                      normalized.forEach(item => { if (item.done === true) completedCount++ })

                      var progressInfo = isObject(lma._planningProgress) ? lma._planningProgress : {}
                      var overallProgress = 0
                      if (isNumber(progressInfo.overall)) {
                        overallProgress = Math.max(0, Math.min(100, Math.round(progressInfo.overall)))
                      } else if (normalized.length > 0) {
                        overallProgress = Math.round((completedCount / normalized.length) * 100)
                      }

                      var checkpointInfo = { reached: 0, total: 0 }
                      if (isObject(progressInfo.checkpoints)) {
                        var checkpoints = progressInfo.checkpoints
                        if (isNumber(checkpoints.reached)) checkpointInfo.reached = checkpoints.reached
                        if (isNumber(checkpoints.total)) checkpointInfo.total = checkpoints.total
                      }

                      global.__planState[uuid] = {
                        items      : normalized,
                        total      : normalized.length,
                        completed  : completedCount,
                        overall    : overallProgress,
                        checkpoints: checkpointInfo,
                        active     : normalized.length > 0,
                        updated    : Date.now()
                      }
                      if (global.__usestream && isFunction(global._mini_a_web_ssePush)) {
                        global._mini_a_web_ssePush(uuid, "plan", { plan: global.__planState[uuid] })
                      }
                    } else {
                      if (isDef(global.__planState[uuid])) delete global.__planState[uuid]
                    }
                  }
                } catch(planErr) {
                  logErr(planErr)
                }
              //} else if (_e == "🏁" || _e == "✅" || _e == "❌") {
              } else if (_e == "🏁" || _e == "🛑") {
                if (isDef(global.__planState[uuid])) {
                  log(`[${uuid}] ${_e} Plan closed`)
                  delete global.__planState[uuid]
                }
                if (_e == "🛑" && global.__usestream && isFunction(global._mini_a_web_sseClose)) {
                  global._mini_a_web_sseClose(uuid, "stopped")
                }
              }
              global.__res[uuid].push({ event: _e, message: m })
              if (global.__usestream && isFunction(global._mini_a_web_ssePush) && _e != "🗺️") {
                global._mini_a_web_ssePush(uuid, "interaction", { event: _e })
              }
              // Only sync to S3 after user prompts (not on every event)
              if (_e == "👤" && isFunction(global._mini_a_web_storeHistory)) {
                try {
                  global._mini_a_web_storeHistory(uuid)
                } catch(syncErr) {
                  logErr(syncErr)
                }
              }
              log("[" + uuid + "] " + _e + " " + m)
            } catch(eee) {
              $err(eee)
              logWarn(`[${uuid}] Plan closed`)
              delete global.__planState[uuid]
            }
          })
          lma.init(merge(global.maArgs, {
            conversation: global._mini_a_web_loadFile(_hfile)
          }))
          global.__conversations[ uuid ] = lma
        } else {
          lma = global.__conversations[ uuid ]
          var _historyFile = global.__usehistory && isString(_hfile) ? global._mini_a_web_loadFile(_hfile) : __
          if (isString(_historyFile) && io.fileExists(_historyFile)) {
            try {
              var _existingConversationPayload = io.readFileJSON(_historyFile)
              if (isMap(_existingConversationPayload) && isArray(_existingConversationPayload.c) && isDef(lma.llm) && isFunction(lma.llm.getGPT)) {
                lma.llm.getGPT().setConversation(_existingConversationPayload.c)
                if (lma._use_lc && isDef(lma.lc_llm) && isFunction(lma._copyConversationBetweenLlms)) {
                  lma._copyConversationBetweenLlms(lma.llm, lma.lc_llm)
                }
              }
            } catch(loadConversationErr) {
              logErr(loadConversationErr)
            }
          }
        }

        // Only load conversation from file/S3 if this is a new MiniA instance
        // Otherwise use the in-memory conversation to preserve tool results
        var startArgs = merge(global.maArgs, {
          goal        : postData.prompt,
          raw         : true
        })
        if (toBoolean(startArgs.usememory) && isString(global.__memorysessionheader) && global.__memorysessionheader.length > 0 && isMap(request.header)) {
          var headerMemorySessionId = request.header[global.__memorysessionheader]
          if (isDef(headerMemorySessionId)) {
            var normalizedMemorySessionId = String(headerMemorySessionId).trim()
            if (normalizedMemorySessionId.length > 0) startArgs.memorysessionid = normalizedMemorySessionId
          }
        }
        if (global.__usehistory && isString(_hfile)) {
          startArgs.conversation = _hfile
        }
        // Only pass browser context for new conversations to avoid replacing in-memory session state
        if (isNewConversation) {
          if (isMap(postData.browserContext)) {
            startArgs.browsercontext = jsonParse(stringify(postData.browserContext, __, ""), __, __, true)
          } else if (isString(postData.browserContext) && postData.browserContext.trim().length > 0) {
            var parsedPostBrowserContext = af.fromJSSLON(postData.browserContext)
            if (isMap(parsedPostBrowserContext)) startArgs.browsercontext = parsedPostBrowserContext
          }
        }
        var _rma = lma.start(startArgs)

        if (isDef(_rma.answer)) {
          var trimmedAnswer = _rma.answer.trim();
          if (trimmedAnswer.startsWith("```markdown") && trimmedAnswer.endsWith("```")) {
            // Remove markdown fences
            _rma.answer = trimmedAnswer.replace(/^```markdown\s*\n?([\s\S]+?)\n?```$/g, "$1").trim()
          }
        }
        global.__res[uuid].push( { event: "final", message: (isObject(_rma) ? af.toSLON(_rma) : _rma) } )
        if (global.__usestream && isFunction(global._mini_a_web_ssePush)) {
          global._mini_a_web_ssePush(uuid, "interaction", { event: "final" })
        }
        if (global.__usestream && isFunction(global._mini_a_web_sseClose)) {
          global._mini_a_web_sseClose(uuid, "finished")
        }
        if (isFunction(global._mini_a_web_storeHistory)) {
          try {
            global._mini_a_web_storeHistory(uuid)
          } catch(storeErr) {
            logErr(storeErr)
          }
        }
        log("[" + uuid + "] " + (isObject(_rma) ? af.toSLON(_rma) : _rma))
      }).catch((eee) => {
        logErr(eee)
        $err(eee)
      })
    } catch(ee) {
      logErr(ee)
      $err(ee)
    }

    return ow.server.httpd.reply(_res)

# Get results of a prompt
- (httpdService   ): "${onport:-8888}"
  ((uri          )): /result
  ((execURI      )): | #js
    try {
      var postData = jsonParse(request.files.postData)

      if (isDef(postData.request) && postData.request == "stop") {
        global.__conversations[ postData.uuid ].state = "stop"
      }
      var _res = { content: "", status: "processing", history: [] }
      var __attachmentLangMap = {
        md: 'markdown', markdown: 'markdown', json: 'json', yaml: 'yaml', yml: 'yaml',
        csv: 'csv', tsv: 'tsv', xml: 'xml', html: 'html', htm: 'html', css: 'css', scss: 'scss', less: 'less',
        js: 'javascript', mjs: 'javascript', cjs: 'javascript', ts: 'typescript', jsx: 'jsx', tsx: 'tsx',
        py: 'python', rb: 'ruby', go: 'go', java: 'java', kt: 'kotlin', c: 'c', h: 'c', cpp: 'cpp', cc: 'cpp', hpp: 'cpp', cs: 'csharp',
        rs: 'rust', php: 'php', sh: 'bash', bash: 'bash', zsh: 'bash', fish: 'bash', sql: 'sql', toml: 'toml', ini: 'ini', cfg: 'ini', conf: 'ini', env: 'ini',
        properties: 'ini', gradle: 'groovy', dockerfile: 'dockerfile', makefile: 'makefile', cmake: 'cmake', r: 'r', lua: 'lua', swift: 'swift', scala: 'scala'
      }

      function __escapeHtml(str) {
        if (isUnDef(str)) return ''
        return ('' + str)
          .replace(/&/g, '&amp;')
          .replace(/</g, '&lt;')
          .replace(/>/g, '&gt;')
          .replace(/"/g, '&quot;')
          .replace(/'/g, '&#39;')
      }

      function __escapeAttr(str) {
        return __escapeHtml(str).replace(/[\r\n]+/g, ' ')
      }

      function __detectAttachmentLang(name) {
        if (isUnDef(name)) return 'text'
        var lowered = ('' + name).toLowerCase()
        if (lowered == 'dockerfile') return 'dockerfile'
        if (lowered.indexOf('makefile') == 0) return 'makefile'
        var parts = lowered.split('.')
        var ext = parts.length > 1 ? parts.pop() : ''
        if (isDef(__attachmentLangMap[ext])) return __attachmentLangMap[ext]
        return 'text'
      }

      function __formatUserMessage(message) {
        if (isUnDef(message)) return ''
        var text = '' + message
        var attachments = []
        text = text.replace(/```attachment\s+([^\n]+)\n([\s\S]*?)```/gm, function(_, name, content) {
          var cleanName = ('' + name).replace(/[\r\n]+/g, ' ').trim()
          var cleanContent = ('' + content).replace(/\r\n/g, '\n')
          attachments.push({ name: cleanName, content: cleanContent })
          return '§§ATTACHMENT_' + (attachments.length - 1) + '§§'
        })

        var html = __escapeHtml(text).replace(/\n/g, '<br>')
        for (var j = 0; j < attachments.length; j++) {
          var att = attachments[j]
          var placeholder = '§§ATTACHMENT_' + j + '§§'
          var safeName = att.name && att.name.length > 0 ? att.name : 'attachment.txt'
          var safeNameHtml = __escapeHtml(safeName)
          var attrName = __escapeAttr(safeName)
          var encoded = af.fromBytes2String(af.toBase64Bytes(att.content || ''))
          var language = __detectAttachmentLang(att.name)
          var button = '<button class="user-attachment" type="button" data-name="' + attrName + '" data-language="' + __escapeAttr(language) + '" data-content="' + __escapeAttr(encoded) + '">📎 ' + safeNameHtml + '</button>'
          html = html.replace(placeholder, button)
        }

        return html
      }
      if (isDef(global.__res[ postData.uuid ])) {
        // Update last activity
        global.__lastActivity[ postData.uuid ] = Date.now()
        var planState = isDef(global.__planState) ? global.__planState[ postData.uuid ] : __
        var hasActivePlan = isDef(planState) && isArray(planState.items) && planState.items.length > 0

        // Append all messages to content
        var _history = []
        for (var i = 0; i < global.__res[ postData.uuid ].length; i++) {
          var r = global.__res[ postData.uuid ][i]
          if (isDef(r.event)) {
            var _h = { event: r.event }
            if (isDef(r.message)) _h.message = r.message
            _history.push(_h)
          }
          if (r.event == "final") {
            if (i == global.__res[ postData.uuid ].length - 1) _res.status = "finished"
            _res.content += "\n" + r.message + "\n"
            //delete global.__res[ postData.uuid ]
            //break
          } else {
            // Exclude planning (🗺️) messages from the content log; plan panel remains driven by __planState
            if (r.event == "👤" || (r.event == "⚙️" && global.__showexecs) || (r.event == "🖥️" && global.__showexecs) || r.event == "🧩" || r.event == "💡" || r.event == "💭" || r.event == "🌀" || r.event == "🛑" || r.event == "⏳") {
              if (r.event == "👤") {
                _res.content += "<div style=\"text-align: right;\"><i><div style=\"display: inline-block; text-align: left;\">" + __formatUserMessage(r.message) + "</div> " + r.event + "</i>\n<br><br></div>"
              } else {
                _res.content += r.event + " <i><span style=\"color: var(--text); opacity: 0.60;\">" + r.message.replace(/\n/g, "<br>") + "</span></i>\n"
              }
            }
          }
        }
        _res.history = _history
        if (hasActivePlan) {
          _res.plan = {
            active     : true,
            items      : planState.items,
            total      : planState.total,
            completed  : planState.completed,
            overall    : planState.overall,
            checkpoints: planState.checkpoints,
            updated    : planState.updated
          }
        } else {
          _res.plan = {
            active     : false,
            items      : [],
            total      : 0,
            completed  : 0,
            overall    : 0,
            checkpoints: { reached: 0, total: 0 }
          }
        }
      }

      return ow.server.httpd.reply(_res)
    } catch(e) {
      printErr(e)
      return ow.server.httpd.reply({ error: e.toString() })
    }

# Stream events via SSE
- (httpdSSE       ): "${onport:-8888}"
  ((uri          )): /stream
  ((execSSE      )): | #js
    var uuid = __
    try {
      uuid = isDef(request.params) ? request.params.uuid : __
      if (isUnDef(uuid) || String(uuid).length == 0) {
        writer.write("error", { message: "uuid is required" })
        return
      }
      if (isUnDef(global.__sseQueues[uuid])) {
        global.__sseQueues[uuid] = { events: [], closed: false, updated: Date.now() }
      }
      var idx = 0
      var lastPing = Date.now()
      writer.write("ready", { status: "ok", uuid: uuid })
      while (true) {
        var queue = global.__sseQueues[uuid]
        if (isUnDef(queue)) break
        while (idx < queue.events.length) {
          var entry = queue.events[idx]
          writer.write(entry.event, entry.data)
          idx++
          lastPing = Date.now()
        }
        if (queue.closed) break
        if ((Date.now() - lastPing) > 15000) {
          writer.write("ping", { ts: Date.now() })
          lastPing = Date.now()
        }
        sleep(100)
      }
    } catch(e) {
      // Mark queue as closed on error (e.g., client disconnect)
      if (isDef(uuid) && isDef(global.__sseQueues[uuid])) {
        global.__sseQueues[uuid].closed = true
        global.__sseQueues[uuid].updated = Date.now()
      }
      try { 
        writer.write("error", { message: String(e) }) 
      } catch(writeErr) {
        // Log both the original error and the write failure for complete context
        log("SSE error" + (isDef(uuid) ? " for " + uuid : "") + ": " + e + " | Failed to write error response: " + writeErr)
      }
    } finally {
      // Clean up on exit (normal or error); periodic job handles edge cases
      if (isDef(uuid) && isDef(global.__sseQueues[uuid])) {
        // Queue.closed is true in two cases:
        // 1. Normal completion: _mini_a_web_sseClose() sets closed=true, loop exits
        // 2. Error/disconnect: catch block sets closed=true
        if (global.__sseQueues[uuid].closed) {
          delete global.__sseQueues[uuid]
        }
      }
    }

# Convert markdown to static HTML
- (httpdService   ): "${onport:-8888}"
  ((uri          )): /md2html
  ((execURI      )): | #js
    try {
      function inlineSvgCodeBlocks(markdown) {
        if (!isString(markdown) || markdown.length == 0) return markdown
        return markdown.replace(/(^|\n)```svg\s*\n([\s\S]*?)\n```(?=\n|$)/gmi, (match, prefix, content) => {
          var svgContent = isString(content) ? content.trim() : ""
          if (svgContent.length == 0) return prefix
          return prefix + svgContent + "\n"
        })
      }

      var postData = jsonParse(request.files.postData)
      var markdown = (isDef(postData.markdown) ? ("" + postData.markdown) : "").trim()

      if (markdown.length == 0) {
        return ow.server.httpd.reply({ error: "markdown is required" })
      }

      if (global.__usesvg || global.__usevectors) {
        markdown = inlineSvgCodeBlocks(markdown)
      }

      var html = ow.template.html.genStaticVersion4MD(markdown)

      if (isDef(global.__webMetrics) && isDef(global.__webMetrics.html_exports) && isFunction(global.__webMetrics.html_exports.inc)) {
        try { global.__webMetrics.html_exports.inc() } catch(ignore) {}
      }

      return ow.server.httpd.reply({ html: html })
    } catch(e) {
      printErr(e)
      return ow.server.httpd.reply({ error: e.toString() })
    }

# Load history for a session
- (httpdService   ): "${onport:-8888}"
  ((uri          )): /load-history
  ((execURI      )): | #js
    try {
      var postData = jsonParse(request.files.postData)

      if (isUnDef(postData.uuid)) {
        return ow.server.httpd.reply({ error: "uuid is required" })
      }

      if (isUnDef(postData.history) || !Array.isArray(postData.history)) {
        return ow.server.httpd.reply({ error: "history must be an array" })
      }

      // If already stored no need to load again
      if (isDef(global.__res[ postData.uuid ])) {
        logWarn("History for " + postData.uuid + " already loaded")
        return ow.server.httpd.reply({ status: "loaded", uuid: postData.uuid, entries: global.__res[ postData.uuid ].length })
      } else {
        logWarn("History for " + postData.uuid + " not found. Rebuilding from provided history with " + postData.history.length + " entries")
      }

      var sanitized = []
      for (var i = 0; i < postData.history.length; i++) {
        var item = postData.history[i]
        if (isUnDef(item) || isUnDef(item.event)) continue
        var entry = { event: item.event }
        if (isDef(item.message)) entry.message = item.message
        sanitized.push(entry)
      }

      global.__res[ postData.uuid ] = sanitized
      delete global.__conversations[ postData.uuid ]
      global.__lastActivity[ postData.uuid ] = Date.now()
      if (isFunction(global._mini_a_web_storeHistory)) {
        try {
          global._mini_a_web_storeHistory(postData.uuid)
        } catch(syncErr) {
          logErr(syncErr)
        }
      }

      return ow.server.httpd.reply({ status: "loaded", uuid: postData.uuid, entries: sanitized.length })
    } catch(e) {
      printErr(e)
      return ow.server.httpd.reply({ error: e.toString() })
    }

ojob:
  opacks      :
  - openaf: 20250915
  - oJob-common
  - mini-a
  - S3
  catch       : printErrnl("[" + job.name + "] "); printErr(exception)
  logToConsole: true   # to change when finished
  daemon      : true
  argsFromEnvs: true
  loadLibs    :
  - mini-a.js
  - s3.js
  channels    :
    create:
    - name: conversations
    - name: lastActivity
    - name: results

jobs:
# ---------------------
- name : CheckEnv
  exec : | #js
    var hasModelOverride = isDef(args) && isDef(args.model) && ((isString(args.model) && args.model.trim().length > 0) || isMap(args.model))
    if (isUnDef(getEnv("OAF_MODEL")) && !hasModelOverride) {
      throw "OAF_MODEL environment variable not set. Please export OAF_MODEL or provide model= with your model configuration before starting the Mini-A web server."
    }

# ---------------------
- name : Static content
  exec : | #js
    args.path = getOPackPath("mini-a") + "/public"
  to   :
  - (httpdFileBrowse): "${onport:-8888}"
    ((uri          )): /
    #((path         )): public
    ((browse       )): false
    ((default      )): index.md

# -----------
- name : Init
  from :
  - CheckEnv
  check:
    in:
      showexecs       : toBoolean().isBoolean().default(false)
      verbose         : toBoolean().isBoolean().default(false)
      debug           : toBoolean().isBoolean().default(false)
      debugfile       : isString().default(__)
      debugch         : isString().default(__)
      debuglcch       : isString().default(__)
      debugvalch      : isString().default(__)
      usestream       : toBoolean().isBoolean().default(false)
      showthinking    : toBoolean().isBoolean().default(false)
      logpromptheaders: isString().default("")
      memorysessionheader: isString().default("")
      rpm             : toNumber().isNumber().default(__)
      tpm             : toNumber().isNumber().default(__)
      maxsteps        : toNumber().isNumber().default(__)
      earlystopthreshold: toNumber().isNumber().default(__)
      maxcontext      : toNumber().isNumber().default(200000)
      compressgoal    : toBoolean().isBoolean().default(false)
      compressgoaltokens: toNumber().isNumber().default(250)
      compressgoalchars : toNumber().isNumber().default(1000)
      maxpromptchars  : toNumber().isNumber().default(120000)
      knowledge       : isString().default(__)
      rules           : isString().default(__)
      youare          : isString().default(__)
      chatyouare      : isString().default(__)
      homedir         : isString().default(__)
      goalprefix      : isString().default(__)
      libs            : isString().default(__)
      model           : isString().default(__)
      modellc         : isString().default(__)
      modelval        : isString().default(__)
      skillmaxautoload: toNumber().isNumber().default(1)
      skillcontextchars: toNumber().isNumber().default(8000)
      skillmanifestchars: toNumber().isNumber().default(1536)
      modellock       : isString().default(__)
      modelstrategy   : isString().default(__)
      advisormaxuses  : toNumber().isNumber().default(__)
      advisorenable   : toBoolean().isBoolean().default(__)
      advisoronrisk   : toBoolean().isBoolean().default(__)
      advisoronambiguity: toBoolean().isBoolean().default(__)
      advisoronharddecision: toBoolean().isBoolean().default(__)
      advisorcooldownsteps: toNumber().isNumber().default(__)
      advisorbudgetratio: toNumber().isNumber().default(__)
      emergencyreserve: toNumber().isNumber().default(__)
      harddecision    : isString().default(__)
      evidencegate    : toBoolean().isBoolean().default(false)
      evidencegatestrictness: isString().default(__)
      lcescalatedefer : toBoolean().isBoolean().default(__)
      lcbudget        : toNumber().isNumber().default(__)
      llmcomplexity   : toBoolean().isBoolean().default(false)
      usehistory      : toBoolean().isBoolean().default(false)
      useattach       : toBoolean().isBoolean().default(false)
      historypath     : isString().default(".")
      historykeep     : toBoolean().isBoolean().default(false)
      historykeepperiod: toNumber().isNumber().default(__)
      historykeepcount: toNumber().isNumber().default(__)
      useplanning     : toBoolean().isBoolean().default(false)
      updatefreq      : isString().default("auto")
      updateinterval  : toNumber().isNumber().default(3)
      forceupdates    : toBoolean().isBoolean().default(false)
      planlog         : isString().default(__)
      forceplanning   : toBoolean().isBoolean().default(false)
      planfile        : isString().default(__)
      planformat      : isString().default(__)
      plancontent     : isString().default(__)
      saveplannotes   : toBoolean().isBoolean().default(false)
      resumefailed    : toBoolean().isBoolean().default(false)
      useshell        : toBoolean().isBoolean().default(false)
      shell           : isString().default(__)
      readwrite       : toBoolean().isBoolean().default(false)
      checkall        : toBoolean().isBoolean().default(false)
      shellbatch      : toBoolean().isBoolean().default(false)
      shellprefix     : isString().default(__)
      shellallow      : isString().default(__)
      shellbanextra   : isString().default(__)
      shellallowpipes : toBoolean().isBoolean().default(false)
      shelltimeout    : toNumber().isNumber().default(__)
      shellmaxbytes   : toNumber().isNumber().default(__)
      usesandbox      : isString().default(__)
      sandboxprofile  : isString().default(__)
      sandboxnonetwork: toBoolean().isBoolean().default(false)
      mcp             : isString().default(__)
      usetools        : toBoolean().isBoolean().default(false)
      usetoolslc      : toBoolean().isBoolean().default(false)
      usejsontool     : toBoolean().isBoolean().default(__)
      toolfallback    : toBoolean().isBoolean().default(false)
      usediagrams     : toBoolean().isBoolean().default(false)
      usemermaid      : toBoolean().isBoolean().default(__)
      usecharts       : toBoolean().isBoolean().default(false)
      usemaps         : toBoolean().isBoolean().default(false)
      usesvg          : toBoolean().isBoolean().default(false)
      usevectors      : toBoolean().isBoolean().default(false)
      browsercontext  : isString().default(__)
      useascii        : toBoolean().isBoolean().default(false)
      usemath         : toBoolean().isBoolean().default(false)
      historys3bucket : isString().default(__)
      historys3prefix : isString().default("")
      historys3url    : isString().default("https://s3.amazonaws.com")
      historys3accesskey: isString().default(__)
      historys3secret : isString().default(__)
      historys3region : isString().default(__)
      historys3useversion1: toBoolean().isBoolean().default(false)
      historys3ignorecertcheck: toBoolean().isBoolean().default(false)
      mcplazy        : toBoolean().isBoolean().default(false)
      mcpdynamic     : toBoolean().isBoolean().default(false)
      mcpproxy       : toBoolean().isBoolean().default(false)
      mcpproxythreshold: toNumber().isNumber().default(0)
      mcpproxytoon   : toBoolean().isBoolean().default(false)
      mcpprogcall    : toBoolean().isBoolean().default(false)
      mcpprogcallport: toNumber().isNumber().default(0)
      mcpprogcallmaxbytes: toNumber().isNumber().default(4096)
      mcpprogcallresultttl: toNumber().isNumber().default(600)
      mcpprogcalltools: isString().default(__)
      mcpprogcallbatchmax: toNumber().isNumber().default(10)
      toolcachettl   : toNumber().isNumber().default(__)
      useutils       : toBoolean().isBoolean().default(false)
      useskills      : toBoolean().isBoolean().default(false)
      utilsroot      : isString().default(__)
      utilsallow     : isString().default(__)
      utilsdeny      : isString().default(__)
      "mini-a-docs"  : toBoolean().isBoolean().default(false)
      miniadocs      : toBoolean().isBoolean().default(false)
      chatbotmode    : toBoolean().isBoolean().default(false)
      adaptiverouting: toBoolean().isBoolean().default(false)
      routerorder    : isString().default(__)
      routerallow    : isString().default(__)
      routerdeny     : isString().default(__)
      routerproxythreshold: toNumber().isNumber().default(__)
      usememory      : toBoolean().isBoolean().default(false)
      memoryuser     : toBoolean().isBoolean().default(false)
      memoryusersession: toBoolean().isBoolean().default(false)
      memoryscope    : isString().default(__)
      memorysessionid: isString().default(__)
      memorych       : isString().default(__)
      memorysessionch: isString().default(__)
      memorymaxpersection: toNumber().isNumber().default(__)
      memorymaxentries: toNumber().isNumber().default(__)
      memorycompactevery: toNumber().isNumber().default(__)
      memorydedup    : toBoolean().isBoolean().default(__)
      memorypromote  : isString().default(__)
      memorystaledays: toNumber().isNumber().default(__)
      memoryinject   : isString().default(__)
      usewiki        : toBoolean().isBoolean().default(false)
      wikiaccess     : isString().default(__)
      wikibackend    : isString().default(__)
      wikiroot       : isString().default(__)
      wikibucket     : isString().default(__)
      wikiprefix     : isString().default(__)
      wikiurl        : isString().default(__)
      wikiaccesskey  : isString().default(__)
      wikisecret     : isString().default(__)
      wikiregion     : isString().default(__)
      wikiuseversion1: toBoolean().isBoolean().default(false)
      wikiignorecertcheck: toBoolean().isBoolean().default(false)
      wikilintstaleddays: toNumber().isNumber().default(__)
      promptprofile  : isString().default(__)
      systempromptbudget: toNumber().isNumber().default(__)
      format         : isString().default(__)
      auditch        : isString().default(__)
      toollog        : isString().default(__)
      metricsch      : isString().default(__)
      usedelegation  : toBoolean().isBoolean().default(false)
      usea2a         : toBoolean().isBoolean().default(false)
      workers        : isString().default(__)
      maxconcurrent  : toNumber().isNumber().default(4)
      delegationmaxdepth: toNumber().isNumber().default(3)
      delegationtimeout: toNumber().isNumber().default(300000)
      delegationmaxretries: toNumber().isNumber().default(2)
      workerreg      : toNumber().isNumber().default(__)
      workerregtoken : isString().default(__)
      workerevictionttl: toNumber().isNumber().default(60000)
      workerregurl   : isString().default(__)
      workerreginterval: toNumber().isNumber().default(__)
      workerskills   : isString().default(__)
      workertags     : isString().default(__)
      showdelegate   : toBoolean().isBoolean().default(false)
      deepresearch   : toBoolean().isBoolean().default(false)
      maxcycles      : toNumber().isNumber().default(3)
      validationgoal : isString().default(__)
      valgoal        : isString().default(__)
      validationthreshold: isString().default("PASS")
      persistlearnings: toBoolean().isBoolean().default(true)
      agent          : isString().default(__)
      agentfile      : isString().default(__)
      secpass        : isString().default(__)
      extracommands  : isString().default(__)
      extraskills    : isString().default(__)
      extrahooks     : isString().default(__)
      ssequeuetimeout: toNumber().isNumber().default(120)
  exec : | #js
    if (isDef(args.usemermaid)) {
      if (isUnDef(args.usediagrams)) args.usediagrams = args.usemermaid
      delete args.usemermaid
    }
    if (isDef(args.valgoal)) {
      if (isUnDef(args.validationgoal)) args.validationgoal = args.valgoal
      delete args.valgoal
    }
    if (isString(args.homedir) && args.homedir.trim().length > 0) {
      var _hdArg = args.homedir.trim()
      try { _hdArg = String(new java.io.File(_hdArg).getCanonicalPath()) } catch(ignoreHdErr) {}
      var _hd = _hdArg
      __gHDir = function() { return _hd }
    }
    if (MiniA.shouldWarnUnknownArgs(args)) {
      MiniA.warnUnknownArgs(args, {
        logger: function(message) { logWarn(message) }
      })
    }
    global.__res = {}
    global.__usehistory = args.usehistory
    global.__historypath = args.historypath
    global.__historykeep = args.historykeep
    global.__conversations = {}
    global.__lastActivity = { }
    global.__showexecs = args.showexecs
    global.__usestream = args.usestream
    global.__showthinking = args.showthinking
    global.__maxpromptchars = args.maxpromptchars
    global.__logpromptheaders = args.logpromptheaders.split(",").map(h => h.trim().toLowerCase()).filter(h => h.length > 0)
    global.__memorysessionheader = isString(args.memorysessionheader) ? args.memorysessionheader.trim().toLowerCase() : ""
    global.__useattach = args.useattach
    global.__usesvg = args.usesvg
    global.__usevectors = args.usevectors
    global.__usemath = args.usemath
    global.__planState = {}
    global.__sseQueues = {}
    if (isUnDef(global.__webMetrics)) {
      global.__webMetrics = { html_exports: $atomic(0, "long") }
      try {
        ow.metrics.add("mini-a-web", () => {
          return { html_exports: global.__webMetrics.html_exports.get() }
        })
      } catch(metricsErr) {
        logErr(metricsErr)
      }
    }
    if (global.__usehistory && isString(global.__historypath)) {
      try {
        io.mkdir(global.__historypath)
      } catch(ignore) {}
    }

    global.__historys3bucket = args.historys3bucket
    global.__historys3client = __
    global.__historys3enabled = false
    global.__historys3prefix = isString(args.historys3prefix) ? String(args.historys3prefix) : ""
    if (global.__historys3prefix.length > 0) {
      while (global.__historys3prefix.charAt(0) == "/") {
        global.__historys3prefix = global.__historys3prefix.substring(1)
      }
      while (global.__historys3prefix.length > 0 && global.__historys3prefix.charAt(global.__historys3prefix.length - 1) == "/") {
        global.__historys3prefix = global.__historys3prefix.substring(0, global.__historys3prefix.length - 1)
      }
    }

    if (global.__usehistory && isString(global.__historys3bucket) && global.__historys3bucket.length > 0) {
      try {
        global.__historys3client = new S3(args.historys3url, args.historys3accesskey, args.historys3secret, args.historys3region, args.historys3useversion1, args.historys3ignorecertcheck)
        global.__historys3enabled = true
        log("History S3 storage enabled for bucket " + global.__historys3bucket + (global.__historys3prefix.length > 0 ? (" with prefix " + global.__historys3prefix) : ""))
      } catch(initErr) {
        logErr(initErr)
        global.__historys3client = __
        global.__historys3enabled = false
      }
    }

    if (isUnDef(args.__format)) {
      args.__format = isDef(args.format) ? args.format : "md"
    }
    args.__interaction_source = "mini-a-web"
    
    var browserContext = __
    if (isMap(args.browsercontext)) {
      browserContext = jsonParse(stringify(args.browsercontext, __, ""), __, __, true)
    } else if (isString(args.browsercontext) && args.browsercontext.trim().length > 0) {
      var parsedBrowserContext = af.fromJSSLON(args.browsercontext)
      if (isMap(parsedBrowserContext)) {
        browserContext = parsedBrowserContext
      } else if (toBoolean(args.browsercontext)) {
        browserContext = true
      }
    } else if (toBoolean(args.browsercontext)) {
      browserContext = true
    }

    if ((args.usevectors || args.usesvg) && isUnDef(browserContext)) {
      browserContext = true
    }

    if ((args.usevectors || args.usesvg) && isNumber(args.onport) && browserContext === true) {
      browserContext = {
        viewportWidth: 1280,
        panelWidth: 720,
        fontSize: "16px",
        colorScheme: "dark",
        devicePixelRatio: 2,
        serverPort: args.onport
      }
    }

    args.browsercontext = browserContext
    MiniA.applyLibEnvDefault(args)
    global.maArgs = merge(args, {})
    var needsWorkerRegBootstrap = isNumber(args.workerreg)
    if (!toBoolean(args.mcplazy) || needsWorkerRegBootstrap) {
      var _ma = new MiniA()
      _ma.init( merge( global.maArgs, { mcpdynamic: false } ) )
      if (needsWorkerRegBootstrap) global.__bootstrapAgent = _ma
      else _ma = __
    }

    global._mini_a_web_historyS3Key = (uuid) => {
      if (isUnDef(uuid)) return __
      var clean = String(uuid)
      var key = "c-" + clean + ".json"
      if (global.__historys3prefix.length > 0) {
        key = global.__historys3prefix + "/" + key
      }
      return key
    }

    global._mini_a_web_uuidFromPath = (aFile) => {
      if (isUnDef(aFile) || isUnDef(global.__historypath)) return __
      var base = String(global.__historypath)
      if (base.length > 0 && base.charAt(base.length - 1) != "/") {
        base = base + "/"
      }
      var prefix = base + "c-"
      var file = String(aFile || "")
      if (file.indexOf(prefix) == 0 && file.length > prefix.length + 5) {
        var uuid = file.substring(prefix.length)
        if (uuid.endsWith(".json")) {
          uuid = uuid.substring(0, uuid.length - 5)
        }
        return uuid
      }
      return __
    }

    global._mini_a_web_initSSE = (uuid) => {
      if (isUnDef(uuid)) return
      global.__sseQueues[uuid] = { events: [], closed: false, updated: Date.now() }
    }

    global._mini_a_web_ssePush = (uuid, event, data) => {
      if (!global.__usestream) return
      if (isUnDef(uuid) || isUnDef(event)) return
      if (isUnDef(global.__sseQueues[uuid])) {
        global.__sseQueues[uuid] = { events: [], closed: false, updated: Date.now() }
      }
      global.__sseQueues[uuid].events.push({ event: event, data: data })
      global.__sseQueues[uuid].updated = Date.now()
    }

    global._mini_a_web_sseClose = (uuid, status) => {
      if (!global.__usestream) return
      if (isUnDef(uuid)) return
      if (isUnDef(global.__sseQueues[uuid])) {
        global.__sseQueues[uuid] = { events: [], closed: false, updated: Date.now() }
      }
      if (global.__sseQueues[uuid].closed === true) return
      global.__sseQueues[uuid].events.push({ event: "done", data: { status: status || "finished" } })
      global.__sseQueues[uuid].closed = true
      global.__sseQueues[uuid].updated = Date.now()
    }

    global._mini_a_web_buildHistoryPayload = (uuid) => {
      if (isUnDef(uuid)) return __
      var hfile = global.__historypath + "/c-" + uuid + ".json"

      // Prefer S3 when enabled
      if (global.__historys3enabled) {
        var stream, str
        try {
          var key = global._mini_a_web_historyS3Key(uuid)
          log("S3 history get (payload) bucket=" + global.__historys3bucket + " key=" + key)
          stream = global.__historys3client.getObjectStream(global.__historys3bucket, key)
          str = af.fromInputStream2String(stream)
        } catch(getErr) {
          // Ignore missing objects; log other errors
          if (isDef(getErr) && String(getErr).indexOf("NoSuchKey") < 0) {
            logErr(getErr)
          }
        } finally {
          if (isDef(stream)) { try { stream.close() } catch(ignore) {} }
        }
        if (isDef(str)) {
          try {
            log("S3 history got payload for uuid=" + uuid + " size=" + str.length)
            return str
          } catch(convErr) { logErr(convErr) }
        }
      }

      // Otherwise try local file if present
      if (io.fileExists(hfile)) {
        try {
          return io.readFileString(hfile)
        } catch(readErr) {
          logErr(readErr)
        }
      }

      // Build from in-memory events
      if (isDef(global.__res[uuid]) && isArray(global.__res[uuid]) && global.__res[uuid].length > 0) {
        var data = []
        for (var i = 0; i < global.__res[uuid].length; i++) {
          var entry = global.__res[uuid][i]
          if (isUnDef(entry) || isUnDef(entry.event)) continue
          var msg = isDef(entry.message) ? entry.message : ""
          switch(entry.event) {
          case "👤":
            data.push({ role: "user", content: msg })
            break
          case "🤖":
          case "⬅️":
          case "🏁":
          case "✅":
          case "❌":
            data.push({ role: "assistant", content: msg })
            break
          case "⚙️":
          case "🖥️":
          case "📚":
          case "ℹ️":
          case "🧩":
          case "📂":
          case "⚠️":
          case "🛑":
            data.push({ role: "system", content: msg })
            break
          default:
            // Skip remaining events from being persisted
          }
        }
        if (data.length > 0) {
          return stringify({ u: new Date(), c: data }, __, "")
        }
      }
      return __
    }

    global._mini_a_web_storeHistory = (uuid) => {
      if (!global.__historys3enabled) return
      var payload = global._mini_a_web_buildHistoryPayload(uuid)
      if (isUnDef(payload)) return
      var stream, bytes
      try {
        var key = global._mini_a_web_historyS3Key(uuid)
        log("S3 history put bucket=" + global.__historys3bucket + " key=" + key + " size=" + (isDef(payload) ? payload.length : 0))
        global.__historys3client.putObjectStream(global.__historys3bucket, key, af.fromString2InputStream(payload), {}, "application/json")
      } catch(storeErr) {
        logErr(storeErr)
      } finally {
        if (isDef(stream)) {
          try { stream.close() } catch(ignore) {}
        }
      }
    }

    global._mini_a_web_deleteHistory = (uuid) => {
      if (isUnDef(uuid)) return
      var localFile = isString(global.__historypath) ? (global.__historypath + "/c-" + uuid + ".json") : __
      // Remove remote if enabled
      if (global.__historys3enabled) {
        try {
          var key = global._mini_a_web_historyS3Key(uuid)
          log("S3 history delete bucket=" + global.__historys3bucket + " key=" + key)
          global.__historys3client.removeObject(global.__historys3bucket, key)
        } catch(removeErr) {
          logErr(removeErr)
        }
      }
      // Always try to remove local cache file if present
      if (isString(localFile) && io.fileExists(localFile)) {
        try { io.rm(localFile) } catch(ignore) {}
      }
    }

    global._mini_a_web_saveFile = (aFile, aMap) => {
      var uuid = global._mini_a_web_uuidFromPath(aFile)
      if (global.__historys3enabled && isDef(uuid)) {
        // Save to S3 instead of local
        var payload
        try {
          payload = stringify(aMap, __, "")
        } catch(jsonErr) { logErr(jsonErr); return }
        var stream, bytes
        try {
          var key = global._mini_a_web_historyS3Key(uuid)
          bytes = af.fromString2Bytes(payload, "utf-8")
          log("S3 history save bucket=" + global.__historys3bucket + " key=" + key + " size=" + (isDef(bytes) ? bytes.length : 0))
          stream = new Packages.java.io.ByteArrayInputStream(bytes)
          global.__historys3client.putObjectStream(global.__historys3bucket, key, stream, {}, "application/json")
        } catch(storeErr) {
          logErr(storeErr)
        } finally {
          if (isDef(stream)) { try { stream.close() } catch(ignore) {} }
        }
      } else {
        // Local save
        try { io.writeFileJSON(aFile, aMap, "") } catch(writeErr) { logErr(writeErr) }
      }
    }

    global._mini_a_web_historyExists = (uuid) => {
      if (isUnDef(uuid)) return false
      var localFile = isString(global.__historypath) ? (global.__historypath + "/c-" + uuid + ".json") : __
      if (global.__historys3enabled) {
        var stream
        try {
          var key = global._mini_a_web_historyS3Key(uuid)
          log("S3 history exists? bucket=" + global.__historys3bucket + " key=" + key)
          stream = global.__historys3client.getObjectStream(global.__historys3bucket, key)
          log("S3 history exists: true for key=" + key)
          return true
        } catch(getErr) {
          // Missing object is not an error
          try { if (String(getErr).indexOf("NoSuchKey") >= 0) log("S3 history exists: false for key=" + global._mini_a_web_historyS3Key(uuid)) } catch(ignore) {}
          return false
        } finally {
          if (isDef(stream)) { try { stream.close() } catch(ignore) {} }
        }
      }
      return isString(localFile) && io.fileExists(localFile)
    }

    global._mini_a_web_loadFile = (aFile) => {
      // Can be __
      if (global.__historys3enabled && isString(aFile)) {
        var uuid = global._mini_a_web_uuidFromPath(aFile)
        if (isDef(uuid)) {
          var stream, str
          try {
            var key = global._mini_a_web_historyS3Key(uuid)
            log("S3 history get (load) bucket=" + global.__historys3bucket + " key=" + key + " -> file=" + aFile)
            stream = global.__historys3client.getObjectStream(global.__historys3bucket, key)
            str = af.fromInputStream2String(stream)
          } catch(getErr) {
            // Ignore missing objects
            if (isDef(getErr) && String(getErr).indexOf("NoSuchKey") < 0) {
              logErr(getErr)
            }
          } finally {
            if (isDef(stream)) {
              try { stream.close() } catch(ignore) {}
            }
          }
          if (isDef(str)) {
            try {
              log("S3 history downloaded uuid=" + uuid + " size=" + str.length + " -> " + aFile)
              io.writeFileString(aFile, str)
            } catch(writeErr) {
              logErr(writeErr)
            }
          }
        }
      }
      return aFile
    }

# ---------------------------------------
- name : Periodic cleanup of old sessions
  type : periodic
  typeArgs:
    interval: 300000  # every 5 minutes
  args :
    historyretention: toNumber().isNumber().default(600)  # 10 minutes
    ssequeuetimeout: toNumber().isNumber().default(120)   # SSE queue timeout in seconds (2 minutes)
  exec : | #js
    var toDelete = []
    for (var uuid in global.__lastActivity) {
      // If no activity for more than 5 minutes, delete session
      if (now() - global.__lastActivity[ uuid ] > args.historyretention * 1000) {
        toDelete.push(uuid)
      }
    }
    for (var i = 0; i < toDelete.length; i++) {
      var uuid = toDelete[i]
      delete global.__lastActivity[ uuid ]
      delete global.__res[ uuid ]
      delete global.__conversations[ uuid ]
      if (isDef(global.__planState) && isDef(global.__planState[ uuid ])) delete global.__planState[ uuid ]
      if (global.__usehistory && !global.__historykeep && isFunction(global._mini_a_web_deleteHistory)) {
        try {
          global._mini_a_web_deleteHistory(uuid)
        } catch(cleanErr) {
          logErr(cleanErr)
        }
      }
      log("Cleaned up session " + uuid)
    }

    // Clean up stale SSE queues (prevent memory leaks from abrupt disconnections)
    var sseTimeoutMs = args.ssequeuetimeout * 1000
    var sseNow = Date.now()
    var sseToDelete = []
    for (var uuid in global.__sseQueues) {
      var queue = global.__sseQueues[uuid]
      // Remove queues that are closed or haven't been updated within the timeout period
      // Also remove queues with no timestamp (defensive - shouldn't happen in normal flow)
      if (isDef(queue) && (queue.closed || isUnDef(queue.updated) || (sseNow - queue.updated > sseTimeoutMs))) {
        sseToDelete.push(uuid)
      }
    }
    for (var i = 0; i < sseToDelete.length; i++) {
      var uuid = sseToDelete[i]
      delete global.__sseQueues[uuid]
      log("Cleaned up SSE queue " + uuid)
    }

# ---------------------------------------
- name : Shutdown history S3 client
  type : shutdown
  exec : | #js
    if (isDef(global.__historys3client)) {
      try { global.__historys3client.close() } catch(ignore) {}
      global.__historys3client = __
      global.__historys3enabled = false
    }