diff --git a/.claude/rules/skills.md b/.claude/rules/skills.md
index ded26de98b2..1dc797dda0e 100644
--- a/.claude/rules/skills.md
+++ b/.claude/rules/skills.md
@@ -31,16 +31,19 @@ activation:
tags:
- "devops"
max_context_tokens: 2000
-metadata:
- openclaw:
- requires:
- bins: [docker, kubectl]
- env: [KUBECONFIG]
+requires:
+ bins: [docker, kubectl]
+ env: [KUBECONFIG]
---
# Skill instructions here...
```
+Only the top-level `requires:` block is supported. The legacy nested shape
+`metadata.openclaw.requires` is unsupported and ignored by the current parser,
+so older external skills must be migrated instead of relying on silent
+compatibility.
+
## Selection Pipeline
1. **Gating** -- Check binary/env/config requirements; skip skills whose prerequisites are missing
diff --git a/.dockerignore b/.dockerignore
index 32b9468cabd..09a7c89ec53 100644
--- a/.dockerignore
+++ b/.dockerignore
@@ -5,4 +5,3 @@ target/
*.md
!CLAUDE.md
node_modules/
-tools-src/
diff --git a/.githooks/pre-commit b/.githooks/pre-commit
index 9b9913d2d10..5a833d4d2fc 100755
--- a/.githooks/pre-commit
+++ b/.githooks/pre-commit
@@ -24,7 +24,7 @@ if $NEEDS_CHECK; then
fi
# i18n parity: when any language pack changes, all languages must stay in sync.
-if echo "$STAGED" | grep -qE '^src/channels/web/static/i18n/.*\.js$'; then
+if echo "$STAGED" | grep -qE '^crates/ironclaw_gateway/static/i18n/.*\.js$'; then
echo "pre-commit: checking i18n parity..."
if ! ./scripts/check-i18n-parity.sh; then
echo ""
diff --git a/.github/ISSUE_TEMPLATE/qa-bug.yml b/.github/ISSUE_TEMPLATE/qa-bug.yml
new file mode 100644
index 00000000000..ef1d912a642
--- /dev/null
+++ b/.github/ISSUE_TEMPLATE/qa-bug.yml
@@ -0,0 +1,94 @@
+name: QA Bug Report
+description: Bug found during QA testing on staging or hosted environments
+title: "[QA] "
+labels: ["qa-bug"]
+body:
+ - type: dropdown
+ id: environment
+ attributes:
+ label: Environment
+ description: Where was this bug found?
+ options:
+ - hosted-staging (crab shack)
+ - hosted-production
+ - local (cloned ironclaw)
+ - railway-staging
+ validations:
+ required: true
+
+ - type: input
+ id: version
+ attributes:
+ label: Version / Commit Hash
+ description: Paste the commit hash from staging at time of discovery (run `git rev-parse HEAD` or find it on the Railway deploy)
+ placeholder: "e.g. abcdef1"
+ validations:
+ required: true
+
+ - type: input
+ id: qa-date
+ attributes:
+ label: QA Test Date
+ description: Date you discovered this (YYYY-MM-DD)
+ placeholder: "e.g. 2026-04-12"
+ validations:
+ required: true
+
+ - type: input
+ id: feature-area
+ attributes:
+ label: Feature Area
+ description: What part of the app? (e.g. Google Suite extension, Telegram pairing, auth flow)
+ placeholder: "e.g. Extensions → Google Suite install"
+ validations:
+ required: true
+
+ - type: textarea
+ id: steps
+ attributes:
+ label: Steps to Reproduce
+ description: Exact steps — numbered, specific, no summaries
+ placeholder: |
+ 1. Open extensions tab
+ 2. Click "Install Google Suite"
+ 3. Fill in credentials and click Save
+ 4. ...
+ validations:
+ required: true
+
+ - type: textarea
+ id: expected
+ attributes:
+ label: Expected Behavior
+ description: What should happen?
+ validations:
+ required: true
+
+ - type: textarea
+ id: actual
+ attributes:
+ label: Actual Behavior
+ description: What actually happened? Include the exact error message/text.
+ placeholder: "Error: 'Failed to authenticate with Google: invalid_grant' shown in red toast"
+ validations:
+ required: true
+
+ - type: textarea
+ id: logs
+ attributes:
+ label: Logs / Screenshots
+ description: Paste relevant logs, error output, or attach screenshots. Drag files here.
+ validations:
+ required: false
+
+ - type: checkboxes
+ id: checklist
+ attributes:
+ label: Pre-submit checklist
+ options:
+ - label: Title is specific (not "fix Google Suite" but "Google Suite install throws invalid_grant on OAuth step")
+ required: true
+ - label: Commit hash is filled in
+ required: true
+ - label: Steps are numbered and reproducible
+ required: true
diff --git a/.github/workflows/docker.yml b/.github/workflows/docker.yml
index 9c6bfacb5ee..9601165fa41 100644
--- a/.github/workflows/docker.yml
+++ b/.github/workflows/docker.yml
@@ -85,6 +85,13 @@ jobs:
echo "tags=${TAGS}" >> "$GITHUB_OUTPUT"
echo "worker_tags=${WORKER_TAGS}" >> "$GITHUB_OUTPUT"
+ # Staging builds get pre-bundled WASM extensions
+ if [[ "${EVENT_NAME}" == "schedule" || "${INPUT_TAG}" == "staging" ]]; then
+ echo "target=runtime-staging" >> "$GITHUB_OUTPUT"
+ else
+ echo "target=runtime" >> "$GITHUB_OUTPUT"
+ fi
+
- name: Set up Docker Buildx
uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3
@@ -100,6 +107,7 @@ jobs:
context: .
push: true
tags: ${{ steps.tags.outputs.tags }}
+ target: ${{ steps.tags.outputs.target }}
platforms: linux/amd64
cache-from: type=gha
cache-to: type=gha,mode=max
@@ -115,6 +123,36 @@ jobs:
cache-from: type=gha,scope=worker
cache-to: type=gha,mode=max,scope=worker
+ - name: Create releases-manager app token
+ id: app-token
+ continue-on-error: true
+ uses: actions/create-github-app-token@fee1f7d63c2ff003460e3d139729b119787bc349 # v2
+ with:
+ app-id: ${{ secrets.GH_RELEASES_MANAGER_APP_ID }}
+ private-key: ${{ secrets.GH_RELEASES_MANAGER_APP_PRIVATE_KEY }}
+ owner: nearai
+ repositories: ironclaw-dind
+
+ - name: Trigger ironclaw-dind Build & Push
+ if: steps.app-token.outcome == 'success'
+ continue-on-error: true
+ env:
+ GH_TOKEN: ${{ steps.app-token.outputs.token }}
+ EVENT_NAME: ${{ github.event_name }}
+ INPUT_TAG: ${{ inputs.tag }}
+ VERSION: ${{ steps.version.outputs.version }}
+ run: |
+ if [[ "${EVENT_NAME}" == "workflow_call" && -n "${VERSION}" ]]; then
+ gh api repos/nearai/ironclaw-dind/dispatches \
+ --method POST \
+ -f event_type="ironclaw_image_published" \
+ -f client_payload[version]="${VERSION}"
+ elif [[ "${EVENT_NAME}" == "schedule" ]] || [[ "${INPUT_TAG}" == "staging" ]]; then
+ gh api repos/nearai/ironclaw-dind/dispatches \
+ --method POST \
+ -f event_type="ironclaw_image_published"
+ fi
+
- name: Summary
run: |
{
diff --git a/Cargo.lock b/Cargo.lock
index b819442268c..dabcba57f8c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4,9 +4,9 @@ version = 4
[[package]]
name = "addr2line"
-version = "0.24.2"
+version = "0.26.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfbe277e56a376000877090da837660b4427aad530e3028d44e0bffe4f89a1c1"
+checksum = "59317f77929f0e679d39364702289274de2f0f0b22cbf50b2b8cff2169a0b27a"
dependencies = [
"gimli",
]
@@ -210,15 +210,6 @@ version = "1.0.102"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7f202df86484c868dbad7eaa557ef785d5c66295e41b460ef922eca0723b842c"
-[[package]]
-name = "ar_archive_writer"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7eb93bbb63b9c227414f6eb3a0adfddca591a8ce1e9b60661bb08969b87e340b"
-dependencies = [
- "object 0.37.3",
-]
-
[[package]]
name = "arbitrary"
version = "1.4.2"
@@ -1083,6 +1074,15 @@ version = "2.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "843867be96c8daad0d758b57df9392b6d8d271134fce549de6ce169ff98a92af"
+[[package]]
+name = "bitmaps"
+version = "2.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "031043d04099746d8db04daf1fa424b2bc8bd69d92b25962dcde24da39ab64a2"
+dependencies = [
+ "typenum",
+]
+
[[package]]
name = "bitvec"
version = "1.0.1"
@@ -1781,32 +1781,53 @@ dependencies = [
"libc",
]
+[[package]]
+name = "cranelift-assembler-x64"
+version = "0.130.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "046d4b584c3bb9b5eb500c8f29549bec36be11000f1ba2a927cef3d1a9875691"
+dependencies = [
+ "cranelift-assembler-x64-meta",
+]
+
+[[package]]
+name = "cranelift-assembler-x64-meta"
+version = "0.130.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9b194a7870becb1490366fc0ae392ccd188065ff35f8391e77ac659db6fb977"
+dependencies = [
+ "cranelift-srcgen",
+]
+
[[package]]
name = "cranelift-bforest"
-version = "0.115.1"
+version = "0.130.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88c1d02b72b6c411c0a2e92b25ed791ad5d071184193c08a34aa0fdcdf000b72"
+checksum = "bb6a4ab44c6b371e661846b97dab687387a60ac4e2f864e2d4257284aad9e889"
dependencies = [
"cranelift-entity",
+ "wasmtime-internal-core",
]
[[package]]
name = "cranelift-bitset"
-version = "0.115.1"
+version = "0.130.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "720b93bd86ebbb23ebfb2db1ed44d54b2ecbdbb2d034d485bc64aa605ee787ab"
+checksum = "b8b7a44150c2f471a94023482bda1902710746e4bed9f9973d60c5a94319b06d"
dependencies = [
"serde",
"serde_derive",
+ "wasmtime-internal-core",
]
[[package]]
name = "cranelift-codegen"
-version = "0.115.1"
+version = "0.130.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aed3d2d9914d30b460eedd7fd507720203023997bef71452ce84873f9c93537c"
+checksum = "01b06598133b1dd76758b8b95f8d6747c124124aade50cea96a3d88b962da9fa"
dependencies = [
"bumpalo",
+ "cranelift-assembler-x64",
"cranelift-bforest",
"cranelift-bitset",
"cranelift-codegen-meta",
@@ -1815,79 +1836,93 @@ dependencies = [
"cranelift-entity",
"cranelift-isle",
"gimli",
- "hashbrown 0.14.5",
+ "hashbrown 0.16.1",
+ "libm",
"log",
+ "pulley-interpreter",
"regalloc2",
"rustc-hash 2.1.2",
"serde",
"smallvec",
- "target-lexicon 0.12.16",
+ "target-lexicon",
+ "wasmtime-internal-core",
]
[[package]]
name = "cranelift-codegen-meta"
-version = "0.115.1"
+version = "0.130.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "888c188d32263ec9e048873ff0b68c700933600d553f4412417916828be25f8e"
+checksum = "6190e2e7bcf0a678da2f715363d34ed530fedf7a2f0ab75edaefef72a70465ff"
dependencies = [
+ "cranelift-assembler-x64-meta",
"cranelift-codegen-shared",
+ "cranelift-srcgen",
+ "heck",
+ "pulley-interpreter",
]
[[package]]
name = "cranelift-codegen-shared"
-version = "0.115.1"
+version = "0.130.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ddd5f4114d04ce7e073dd74e2ad16541fc61970726fcc8b2d5644a154ee4127"
+checksum = "f583cf203d1aa8b79560e3b01f929bdacf9070b015eec4ea9c46e22a3f83e4a0"
[[package]]
name = "cranelift-control"
-version = "0.115.1"
+version = "0.130.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92cc4c98d6a4256a1600d93ccd3536f3e77da9b4ca2c279de786ac22876e67d6"
+checksum = "803159df35cc398ae54473c150b16d6c77e92ab2948be638488de126a3328fbc"
dependencies = [
"arbitrary",
]
[[package]]
name = "cranelift-entity"
-version = "0.115.1"
+version = "0.130.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "760af4b5e051b5f82097a27274b917e3751736369fa73660513488248d27f23d"
+checksum = "3109e417257082d88087f5bcce677525bdaa8322b88dd7f175ed1a1fd41d546c"
dependencies = [
"cranelift-bitset",
"serde",
"serde_derive",
+ "wasmtime-internal-core",
]
[[package]]
name = "cranelift-frontend"
-version = "0.115.1"
+version = "0.130.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c0bf77ec0f470621655ec7539860b5c620d4f91326654ab21b075b83900f8831"
+checksum = "14db6b0e0e4994c581092df78d837be2072578f7cb2528f96a6cf895e56dee63"
dependencies = [
"cranelift-codegen",
"log",
"smallvec",
- "target-lexicon 0.12.16",
+ "target-lexicon",
]
[[package]]
name = "cranelift-isle"
-version = "0.115.1"
+version = "0.130.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b665d0a6932c421620be184f9fc7f7adaf1b0bc2fa77bb7ac5177c49abf645b"
+checksum = "ec66ea5025c7317383699778282ac98741d68444f956e3b1d7b62f12b7216e67"
[[package]]
name = "cranelift-native"
-version = "0.115.1"
+version = "0.130.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bb2e75d1bd43dfec10924798f15e6474f1dbf63b0024506551aa19394dbe72ab"
+checksum = "373ade56438e6232619d85678477d0a88a31b3581936e0503e61e96b546b0800"
dependencies = [
"cranelift-codegen",
"libc",
- "target-lexicon 0.12.16",
+ "target-lexicon",
]
+[[package]]
+name = "cranelift-srcgen"
+version = "0.130.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef53619d3cd5c78fd998c6d9420547af26b72e6456f94c2a8a2334cb76b42baa"
+
[[package]]
name = "crc"
version = "3.4.0"
@@ -2355,33 +2390,13 @@ dependencies = [
"dirs-sys-next",
]
-[[package]]
-name = "dirs"
-version = "4.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca3aa72a6f96ea37bbc5aa912f6788242832f75369bdfdadcb0e38423f100059"
-dependencies = [
- "dirs-sys 0.3.7",
-]
-
[[package]]
name = "dirs"
version = "6.0.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c3e8aa94d75141228480295a7d0e7feb620b1a5ad9f12bc40be62411e38cce4e"
dependencies = [
- "dirs-sys 0.5.0",
-]
-
-[[package]]
-name = "dirs-sys"
-version = "0.3.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b1d1d91c932ef41c0f2663aa8b0ca0342d444d842c06914aa0a7e352d0bada6"
-dependencies = [
- "libc",
- "redox_users 0.4.6",
- "winapi",
+ "dirs-sys",
]
[[package]]
@@ -2758,6 +2773,12 @@ version = "0.1.9"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5baebc0774151f905a1a2cc41989300b1e6fbb29aff0ceffa1064fdd3088d582"
+[[package]]
+name = "fixedbitset"
+version = "0.4.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80"
+
[[package]]
name = "flagset"
version = "0.4.7"
@@ -2972,25 +2993,17 @@ dependencies = [
"slab",
]
-[[package]]
-name = "fxhash"
-version = "0.2.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c"
-dependencies = [
- "byteorder",
-]
-
[[package]]
name = "fxprof-processed-profile"
-version = "0.6.0"
+version = "0.8.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "27d12c0aed7f1e24276a241aadc4cb8ea9f83000f34bc062b7cc2d51e3b0fabd"
+checksum = "25234f20a3ec0a962a61770cfe39ecf03cb529a6e474ad8cff025ed497eda557"
dependencies = [
"bitflags 2.11.0",
"debugid",
- "fxhash",
+ "rustc-hash 2.1.2",
"serde",
+ "serde_derive",
"serde_json",
]
@@ -3099,11 +3112,12 @@ dependencies = [
[[package]]
name = "gimli"
-version = "0.31.1"
+version = "0.33.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07e28edb80900c19c28f1072f2e8aeca7fa06b23cd4169cefe1af5aa3260783f"
+checksum = "19e16c5073773ccf057c282be832a59ee53ef5ff98db3aeff7f8314f52ffc196"
dependencies = [
- "fallible-iterator 0.3.0",
+ "fnv",
+ "hashbrown 0.16.1",
"indexmap 2.13.0",
"stable_deref_trait",
]
@@ -3189,7 +3203,6 @@ checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
dependencies = [
"ahash 0.8.12",
"allocator-api2",
- "serde",
]
[[package]]
@@ -3201,7 +3214,6 @@ dependencies = [
"allocator-api2",
"equivalent",
"foldhash 0.1.5",
- "serde",
]
[[package]]
@@ -3213,6 +3225,8 @@ dependencies = [
"allocator-api2",
"equivalent",
"foldhash 0.2.0",
+ "serde",
+ "serde_core",
]
[[package]]
@@ -3717,6 +3731,20 @@ dependencies = [
"icu_properties",
]
+[[package]]
+name = "im-rc"
+version = "15.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "af1955a75fa080c677d3972822ec4bad316169ab1cfc6c257a942c2265dbe5fe"
+dependencies = [
+ "bitmaps",
+ "rand_core 0.6.4",
+ "rand_xoshiro",
+ "sized-chunks",
+ "typenum",
+ "version_check",
+]
+
[[package]]
name = "image"
version = "0.25.10"
@@ -3862,13 +3890,14 @@ dependencies = [
"cron",
"crossterm 0.29.0",
"deadpool-postgres",
- "dirs 6.0.0",
+ "dirs",
"dotenvy",
"ed25519-dalek",
"eventsource-stream",
"flate2",
"fs4",
"futures",
+ "glob",
"hex",
"hkdf",
"hmac",
@@ -3880,6 +3909,7 @@ dependencies = [
"insta",
"ironclaw_common",
"ironclaw_engine",
+ "ironclaw_gateway",
"ironclaw_safety",
"ironclaw_skills",
"ironclaw_tui",
@@ -3927,7 +3957,7 @@ dependencies = [
"tokio-test",
"tokio-tungstenite 0.26.2",
"tokio-util",
- "toml",
+ "toml 0.8.23",
"tower 0.5.3",
"tower-http 0.6.8",
"tracing",
@@ -3936,7 +3966,7 @@ dependencies = [
"url",
"urlencoding",
"uuid",
- "wasmparser 0.220.1",
+ "wasmparser 0.245.1",
"wasmtime",
"wasmtime-wasi",
"webpki-roots 0.26.11",
@@ -3948,8 +3978,10 @@ dependencies = [
name = "ironclaw_common"
version = "0.1.0"
dependencies = [
+ "chrono-tz",
"serde",
"serde_json",
+ "tracing",
]
[[package]]
@@ -3958,6 +3990,8 @@ version = "0.1.0"
dependencies = [
"async-trait",
"chrono",
+ "cron",
+ "ironclaw_common",
"ironclaw_skills",
"monty",
"pretty_assertions",
@@ -3971,6 +4005,16 @@ dependencies = [
"uuid",
]
+[[package]]
+name = "ironclaw_gateway"
+version = "0.1.0"
+dependencies = [
+ "serde",
+ "serde_json",
+ "thiserror 2.0.18",
+ "tracing",
+]
+
[[package]]
name = "ironclaw_safety"
version = "0.2.0"
@@ -5036,25 +5080,16 @@ dependencies = [
[[package]]
name = "object"
-version = "0.36.7"
+version = "0.38.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62948e14d923ea95ea2c7c86c71013138b66525b86bdc08d2dcc262bdb497b87"
+checksum = "271638cd5fa9cca89c4c304675ca658efc4e64a66c716b7cfe1afb4b9611dbbc"
dependencies = [
"crc32fast",
- "hashbrown 0.15.5",
+ "hashbrown 0.16.1",
"indexmap 2.13.0",
"memchr",
]
-[[package]]
-name = "object"
-version = "0.37.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe"
-dependencies = [
- "memchr",
-]
-
[[package]]
name = "once_cell"
version = "1.21.4"
@@ -5288,6 +5323,16 @@ dependencies = [
"sha2",
]
+[[package]]
+name = "petgraph"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4c5cc86750666a3ed20bdaf5ca2a0344f9c67674cae0515bec2da16fbaa47db"
+dependencies = [
+ "fixedbitset",
+ "indexmap 2.13.0",
+]
+
[[package]]
name = "pgvector"
version = "0.4.1"
@@ -5706,16 +5751,6 @@ dependencies = [
"syn 2.0.117",
]
-[[package]]
-name = "psm"
-version = "0.1.30"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3852766467df634d74f0b2d7819bf8dc483a0eb2e3b0f50f756f9cfe8b0d18d8"
-dependencies = [
- "ar_archive_writer",
- "cc",
-]
-
[[package]]
name = "ptr_meta"
version = "0.1.4"
@@ -5759,13 +5794,25 @@ dependencies = [
[[package]]
name = "pulley-interpreter"
-version = "28.0.1"
+version = "43.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8324e531de91a3c25021a30fb7862d39cc516b61fbb801176acb5ff279ea887b"
+checksum = "010dec3755eb61b2f1051ecb3611b718460b7a74c131e474de2af20a845938af"
dependencies = [
"cranelift-bitset",
"log",
- "sptr",
+ "pulley-macros",
+ "wasmtime-internal-core",
+]
+
+[[package]]
+name = "pulley-macros"
+version = "43.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ad360c32e85ca4b083ac0e2b6856e8f11c3d5060dafa7d5dc57b370857fa3018"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn 2.0.117",
]
[[package]]
@@ -5796,7 +5843,7 @@ version = "0.28.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e368e7ddfdeb98c9bca7f8383be1648fd84ab466bf2bc015e94008db6d35611e"
dependencies = [
- "target-lexicon 0.13.5",
+ "target-lexicon",
]
[[package]]
@@ -6013,6 +6060,15 @@ dependencies = [
"getrandom 0.3.4",
]
+[[package]]
+name = "rand_xoshiro"
+version = "0.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6f97cdb2a36ed4183de61b2f824cc45c9f1037f28afe0a322e9fff4c108b5aaa"
+dependencies = [
+ "rand_core 0.6.4",
+]
+
[[package]]
name = "rangemap"
version = "1.7.1"
@@ -6188,7 +6244,7 @@ dependencies = [
"time",
"tokio",
"tokio-postgres",
- "toml",
+ "toml 0.8.23",
"url",
"walkdir",
]
@@ -6209,9 +6265,9 @@ dependencies = [
[[package]]
name = "regalloc2"
-version = "0.11.2"
+version = "0.15.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc06e6b318142614e4a48bc725abbf08ff166694835c43c9dae5a9009704639a"
+checksum = "952ddbfc6f9f64d006c3efd8c9851a6ba2f2b944ba94730db255d55006e0ffda"
dependencies = [
"allocator-api2",
"bumpalo",
@@ -6997,6 +7053,15 @@ dependencies = [
"serde",
]
+[[package]]
+name = "serde_spanned"
+version = "1.1.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6662b5879511e06e8999a8a235d848113e942c9124f211511b16466ee2995f26"
+dependencies = [
+ "serde_core",
+]
+
[[package]]
name = "serde_urlencoded"
version = "0.7.1"
@@ -7040,6 +7105,19 @@ dependencies = [
"syn 2.0.117",
]
+[[package]]
+name = "serde_yaml"
+version = "0.9.34+deprecated"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
+dependencies = [
+ "indexmap 2.13.0",
+ "itoa",
+ "ryu",
+ "serde",
+ "unsafe-libyaml",
+]
+
[[package]]
name = "serde_yml"
version = "0.0.12"
@@ -7101,15 +7179,6 @@ dependencies = [
"lazy_static",
]
-[[package]]
-name = "shellexpand"
-version = "2.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7ccc8076840c4da029af4f87e4e8daeb0fca6b87bbb02e10cb60b791450e11e4"
-dependencies = [
- "dirs 4.0.0",
-]
-
[[package]]
name = "shlex"
version = "1.3.0"
@@ -7192,6 +7261,16 @@ version = "1.0.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b2aa850e253778c88a04c3d7323b043aeda9d3e30d5971937c1855769763678e"
+[[package]]
+name = "sized-chunks"
+version = "0.6.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "16d69225bde7a69b235da73377861095455d298f2b970996eec25ddbb42b3d1e"
+dependencies = [
+ "bitmaps",
+ "typenum",
+]
+
[[package]]
name = "slab"
version = "0.4.12"
@@ -7257,12 +7336,6 @@ dependencies = [
"der",
]
-[[package]]
-name = "sptr"
-version = "0.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b9b39299b249ad65f3b7e96443bad61c02ca5cd3589f46cb6d610a0fd6c0d6a"
-
[[package]]
name = "stable_deref_trait"
version = "1.2.1"
@@ -7517,12 +7590,6 @@ dependencies = [
"xattr",
]
-[[package]]
-name = "target-lexicon"
-version = "0.12.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "61c41af27dd6d1e27b1b16b489db798443478cef1f06a660c96db617ba5de3b1"
-
[[package]]
name = "target-lexicon"
version = "0.13.5"
@@ -7983,11 +8050,26 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dc1beb996b9d83529a9e75c17a1686767d148d70663143c7854d8b4a09ced362"
dependencies = [
"serde",
- "serde_spanned",
+ "serde_spanned 0.6.9",
"toml_datetime 0.6.11",
"toml_edit 0.22.27",
]
+[[package]]
+name = "toml"
+version = "0.9.12+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf92845e79fc2e2def6a5d828f0801e29a2f8acc037becc5ab08595c7d5e9863"
+dependencies = [
+ "indexmap 2.13.0",
+ "serde_core",
+ "serde_spanned 1.1.1",
+ "toml_datetime 0.7.5+spec-1.1.0",
+ "toml_parser",
+ "toml_writer",
+ "winnow 0.7.15",
+]
+
[[package]]
name = "toml_datetime"
version = "0.6.11"
@@ -7997,6 +8079,15 @@ dependencies = [
"serde",
]
+[[package]]
+name = "toml_datetime"
+version = "0.7.5+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "92e1cfed4a3038bc5a127e35a2d360f145e1f4b971b551a2ba5fd7aedf7e1347"
+dependencies = [
+ "serde_core",
+]
+
[[package]]
name = "toml_datetime"
version = "1.1.0+spec-1.1.0"
@@ -8014,7 +8105,7 @@ checksum = "41fe8c660ae4257887cf66394862d21dbca4a6ddd26f04a3560410406a2f819a"
dependencies = [
"indexmap 2.13.0",
"serde",
- "serde_spanned",
+ "serde_spanned 0.6.9",
"toml_datetime 0.6.11",
"toml_write",
"winnow 0.7.15",
@@ -8047,6 +8138,12 @@ version = "0.1.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5d99f8c9a7727884afe522e9bd5edbfc91a3312b36a77b5fb8926e4c31a41801"
+[[package]]
+name = "toml_writer"
+version = "1.1.1+spec-1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "756daf9b1013ebe47a8776667b466417e2d4c5679d441c26230efd9ef78692db"
+
[[package]]
name = "tonic"
version = "0.11.0"
@@ -8490,6 +8587,12 @@ dependencies = [
"subtle",
]
+[[package]]
+name = "unsafe-libyaml"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861"
+
[[package]]
name = "untrusted"
version = "0.9.0"
@@ -8704,13 +8807,24 @@ dependencies = [
]
[[package]]
-name = "wasm-encoder"
-version = "0.221.3"
+name = "wasm-compose"
+version = "0.245.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc8444fe4920de80a4fe5ab564fff2ae58b6b73166b89751f8c6c93509da32e5"
+checksum = "5fd23d12cc95c451c1306db5bc63075fbebb612bb70c53b4237b1ce5bc178343"
dependencies = [
- "leb128",
- "wasmparser 0.221.3",
+ "anyhow",
+ "heck",
+ "im-rc",
+ "indexmap 2.13.0",
+ "log",
+ "petgraph",
+ "serde",
+ "serde_derive",
+ "serde_yaml",
+ "smallvec",
+ "wasm-encoder 0.245.1",
+ "wasmparser 0.245.1",
+ "wat",
]
[[package]]
@@ -8758,33 +8872,6 @@ dependencies = [
"web-sys",
]
-[[package]]
-name = "wasmparser"
-version = "0.220.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8d07b6a3b550fefa1a914b6d54fc175dd11c3392da11eee604e6ffc759805d25"
-dependencies = [
- "ahash 0.8.12",
- "bitflags 2.11.0",
- "hashbrown 0.14.5",
- "indexmap 2.13.0",
- "semver",
- "serde",
-]
-
-[[package]]
-name = "wasmparser"
-version = "0.221.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d06bfa36ab3ac2be0dee563380147a5b81ba10dd8885d7fbbc9eb574be67d185"
-dependencies = [
- "bitflags 2.11.0",
- "hashbrown 0.15.5",
- "indexmap 2.13.0",
- "semver",
- "serde",
-]
-
[[package]]
name = "wasmparser"
version = "0.244.0"
@@ -8804,135 +8891,166 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4f08c9adee0428b7bddf3890fc27e015ac4b761cc608c822667102b8bfd6995e"
dependencies = [
"bitflags 2.11.0",
+ "hashbrown 0.16.1",
"indexmap 2.13.0",
"semver",
+ "serde",
]
[[package]]
name = "wasmprinter"
-version = "0.221.3"
+version = "0.245.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7343c42a97f2926c7819ff81b64012092ae954c5d83ddd30c9fcdefd97d0b283"
+checksum = "5f41517a3716fbb8ccf46daa9c1325f760fcbff5168e75c7392288e410b91ac8"
dependencies = [
"anyhow",
"termcolor",
- "wasmparser 0.221.3",
+ "wasmparser 0.245.1",
]
[[package]]
name = "wasmtime"
-version = "28.0.1"
+version = "43.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "edd30973c65eceb0f37dfcc430d83abd5eb24015fdfcab6912f52949287e04f0"
+checksum = "ce205cd643d661b5ba5ba4717e13730262e8cdbc8f2eacbc7b906d45c1a74026"
dependencies = [
"addr2line",
- "anyhow",
"async-trait",
"bitflags 2.11.0",
"bumpalo",
"cc",
"cfg-if",
"encoding_rs",
+ "futures",
"fxprof-processed-profile",
"gimli",
- "hashbrown 0.14.5",
- "indexmap 2.13.0",
"ittapi",
"libc",
- "libm",
"log",
"mach2",
"memfd",
- "object 0.36.7",
+ "object",
"once_cell",
- "paste",
"postcard",
- "psm",
"pulley-interpreter",
"rayon",
- "rustix 0.38.44",
+ "rustix 1.1.4",
"semver",
"serde",
"serde_derive",
"serde_json",
"smallvec",
- "sptr",
- "target-lexicon 0.12.16",
- "wasm-encoder 0.221.3",
- "wasmparser 0.221.3",
- "wasmtime-asm-macros",
- "wasmtime-cache",
- "wasmtime-component-macro",
- "wasmtime-component-util",
- "wasmtime-cranelift",
+ "target-lexicon",
+ "tempfile",
+ "wasm-compose",
+ "wasm-encoder 0.245.1",
+ "wasmparser 0.245.1",
"wasmtime-environ",
- "wasmtime-fiber",
- "wasmtime-jit-debug",
- "wasmtime-jit-icache-coherence",
- "wasmtime-slab",
- "wasmtime-versioned-export-macros",
- "wasmtime-winch",
+ "wasmtime-internal-cache",
+ "wasmtime-internal-component-macro",
+ "wasmtime-internal-component-util",
+ "wasmtime-internal-core",
+ "wasmtime-internal-cranelift",
+ "wasmtime-internal-fiber",
+ "wasmtime-internal-jit-debug",
+ "wasmtime-internal-jit-icache-coherence",
+ "wasmtime-internal-unwinder",
+ "wasmtime-internal-versioned-export-macros",
+ "wasmtime-internal-winch",
"wat",
- "windows-sys 0.59.0",
+ "windows-sys 0.61.2",
]
[[package]]
-name = "wasmtime-asm-macros"
-version = "28.0.1"
+name = "wasmtime-environ"
+version = "43.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6c21dd30d1f3f93ee390ac1a7ec304ecdbfdab6390e1add41a1f52727b0992b"
+checksum = "0b8b78abf3677d4a0a5db82e5015b4d085ff3a1b8b472cbb8c70d4b769f019ce"
dependencies = [
- "cfg-if",
+ "anyhow",
+ "cpp_demangle",
+ "cranelift-bforest",
+ "cranelift-bitset",
+ "cranelift-entity",
+ "gimli",
+ "hashbrown 0.16.1",
+ "indexmap 2.13.0",
+ "log",
+ "object",
+ "postcard",
+ "rustc-demangle",
+ "semver",
+ "serde",
+ "serde_derive",
+ "sha2",
+ "smallvec",
+ "target-lexicon",
+ "wasm-encoder 0.245.1",
+ "wasmparser 0.245.1",
+ "wasmprinter",
+ "wasmtime-internal-component-util",
+ "wasmtime-internal-core",
]
[[package]]
-name = "wasmtime-cache"
-version = "28.0.1"
+name = "wasmtime-internal-cache"
+version = "43.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cabd563cfbfe75c5bf514081f624ca8d18391a37520d8c794abce702474e688c"
+checksum = "8e4fd4103ba413c0da2e636f73490c6c8e446d708cbde7573703941bc3d6a448"
dependencies = [
- "anyhow",
- "base64 0.21.7",
+ "base64 0.22.1",
"directories-next",
"log",
"postcard",
- "rustix 0.38.44",
+ "rustix 1.1.4",
"serde",
"serde_derive",
"sha2",
- "toml",
- "windows-sys 0.59.0",
+ "toml 0.9.12+spec-1.1.0",
+ "wasmtime-environ",
+ "windows-sys 0.61.2",
"zstd",
]
[[package]]
-name = "wasmtime-component-macro"
-version = "28.0.1"
+name = "wasmtime-internal-component-macro"
+version = "43.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f948a6ef3119d52c9f12936970de28ddf3f9bea04bc65571f4a92d2e5ab38f4"
+checksum = "0d3d6914f34be2f9d78d8ee9f422e834dfc204e71ccce697205fae95fed87892"
dependencies = [
"anyhow",
"proc-macro2",
"quote",
"syn 2.0.117",
- "wasmtime-component-util",
- "wasmtime-wit-bindgen",
- "wit-parser 0.221.3",
+ "wasmtime-internal-component-util",
+ "wasmtime-internal-wit-bindgen",
+ "wit-parser 0.245.1",
]
[[package]]
-name = "wasmtime-component-util"
-version = "28.0.1"
+name = "wasmtime-internal-component-util"
+version = "43.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b9275aa01ceaaa2fa6c0ecaa5267518d80b9d6e9ae7c7ea42f4c6e073e6a69ef"
+checksum = "3751b0616b914fdd87fe1bf804694a078f321b000338e6476bc48a4d6e454f21"
[[package]]
-name = "wasmtime-cranelift"
-version = "28.0.1"
+name = "wasmtime-internal-core"
+version = "43.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0701a44a323267aae4499672dae422b266cee3135a23b640972ec8c0e10a44a2"
+checksum = "22632b187e1b0716f1b9ac57ad29013bed33175fcb19e10bb6896126f82fac67"
dependencies = [
"anyhow",
+ "hashbrown 0.16.1",
+ "libm",
+ "serde",
+]
+
+[[package]]
+name = "wasmtime-internal-cranelift"
+version = "43.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b3ca07b3e0bb3429674b173b5800577719d600774dd81bff58f775c0aaa64ee"
+dependencies = [
"cfg-if",
"cranelift-codegen",
"cranelift-control",
@@ -8940,93 +9058,77 @@ dependencies = [
"cranelift-frontend",
"cranelift-native",
"gimli",
- "itertools 0.12.1",
+ "itertools 0.14.0",
"log",
- "object 0.36.7",
+ "object",
+ "pulley-interpreter",
"smallvec",
- "target-lexicon 0.12.16",
- "thiserror 1.0.69",
- "wasmparser 0.221.3",
+ "target-lexicon",
+ "thiserror 2.0.18",
+ "wasmparser 0.245.1",
"wasmtime-environ",
- "wasmtime-versioned-export-macros",
-]
-
-[[package]]
-name = "wasmtime-environ"
-version = "28.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "264c968c1b81d340355ece2be0bc31a10f567ccb6ce08512c3b7d10e26f3cbe5"
-dependencies = [
- "anyhow",
- "cpp_demangle",
- "cranelift-bitset",
- "cranelift-entity",
- "gimli",
- "indexmap 2.13.0",
- "log",
- "object 0.36.7",
- "postcard",
- "rustc-demangle",
- "semver",
- "serde",
- "serde_derive",
- "smallvec",
- "target-lexicon 0.12.16",
- "wasm-encoder 0.221.3",
- "wasmparser 0.221.3",
- "wasmprinter",
- "wasmtime-component-util",
+ "wasmtime-internal-core",
+ "wasmtime-internal-unwinder",
+ "wasmtime-internal-versioned-export-macros",
]
[[package]]
-name = "wasmtime-fiber"
-version = "28.0.1"
+name = "wasmtime-internal-fiber"
+version = "43.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78505221fd5bd7b07b4e1fa2804edea49dc231e626ad6861adc8f531812973e6"
+checksum = "20c8b2c9704eb1f33ead025ec16038277ccb63d0a14c31e99d5b765d7c36da55"
dependencies = [
- "anyhow",
"cc",
"cfg-if",
- "rustix 0.38.44",
- "wasmtime-asm-macros",
- "wasmtime-versioned-export-macros",
- "windows-sys 0.59.0",
+ "libc",
+ "rustix 1.1.4",
+ "wasmtime-environ",
+ "wasmtime-internal-versioned-export-macros",
+ "windows-sys 0.61.2",
]
[[package]]
-name = "wasmtime-jit-debug"
-version = "28.0.1"
+name = "wasmtime-internal-jit-debug"
+version = "43.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0cec0a8e5620ae71bfcaaec78e3076be5b6ebf869f4e6191925d73242224a915"
+checksum = "d950310d07391d34369f62c48336ebb14eacbd4d6f772bb5f349c24e838e0664"
dependencies = [
- "object 0.36.7",
- "rustix 0.38.44",
- "wasmtime-versioned-export-macros",
+ "cc",
+ "object",
+ "rustix 1.1.4",
+ "wasmtime-internal-versioned-export-macros",
]
[[package]]
-name = "wasmtime-jit-icache-coherence"
-version = "28.0.1"
+name = "wasmtime-internal-jit-icache-coherence"
+version = "43.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9bedb677ca1b549d98f95e9e1f9251b460090d99a2c196a0614228c064bf2e59"
+checksum = "3606662c156962d096be3127b8b8ae8ee2f8be3f896dad29259ff01ddb64abfd"
dependencies = [
- "anyhow",
"cfg-if",
"libc",
- "windows-sys 0.59.0",
+ "wasmtime-internal-core",
+ "windows-sys 0.61.2",
]
[[package]]
-name = "wasmtime-slab"
-version = "28.0.1"
+name = "wasmtime-internal-unwinder"
+version = "43.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "564905638c132c275d365c1fa074f0b499790568f43148d29de84ccecfb5cb31"
+checksum = "75eef0747e52dc545b075f64fd0e0cc237ae738e641266b1970e07e2d744bc32"
+dependencies = [
+ "cfg-if",
+ "cranelift-codegen",
+ "log",
+ "object",
+ "wasmtime-environ",
+]
[[package]]
-name = "wasmtime-versioned-export-macros"
-version = "28.0.1"
+name = "wasmtime-internal-versioned-export-macros"
+version = "43.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e91092e6cf77390eeccee273846a9327f3e8f91c3c6280f60f37809f0e62d29"
+checksum = "d8b0a5dab02a8fb527f547855ecc0e05f9fdc3d5bd57b8b080349408f9a6cece"
dependencies = [
"proc-macro2",
"quote",
@@ -9034,12 +9136,41 @@ dependencies = [
]
[[package]]
-name = "wasmtime-wasi"
-version = "28.0.1"
+name = "wasmtime-internal-winch"
+version = "43.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8007342bd12ff400293a817973f7ecd6f1d9a8549a53369a9c1af357166f1f1e"
+dependencies = [
+ "cranelift-codegen",
+ "gimli",
+ "log",
+ "object",
+ "target-lexicon",
+ "wasmparser 0.245.1",
+ "wasmtime-environ",
+ "wasmtime-internal-cranelift",
+ "winch-codegen",
+]
+
+[[package]]
+name = "wasmtime-internal-wit-bindgen"
+version = "43.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a8e04b9a4c68ad018b330a4f4914b82b01dc3582d715ce21a93564c7f26b19f"
+checksum = "7900c3e3c1d6e475bc225d73b02d6d5484815f260022e6964dca9558e50dd01a"
dependencies = [
"anyhow",
+ "bitflags 2.11.0",
+ "heck",
+ "indexmap 2.13.0",
+ "wit-parser 0.245.1",
+]
+
+[[package]]
+name = "wasmtime-wasi"
+version = "43.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed3e3ddcfad69e9eb025bd19bff70dad45bafe1d6eacd134c0ffdfc4c161d045"
+dependencies = [
"async-trait",
"bitflags 2.11.0",
"bytes",
@@ -9052,44 +9183,29 @@ dependencies = [
"futures",
"io-extras",
"io-lifetimes",
- "rustix 0.38.44",
+ "rustix 1.1.4",
"system-interface",
- "thiserror 1.0.69",
+ "thiserror 2.0.18",
"tokio",
"tracing",
"url",
"wasmtime",
+ "wasmtime-wasi-io",
"wiggle",
- "windows-sys 0.59.0",
-]
-
-[[package]]
-name = "wasmtime-winch"
-version = "28.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b111d909dc604c741bd8ac2f4af373eaa5c68c34b5717271bcb687688212cef8"
-dependencies = [
- "anyhow",
- "cranelift-codegen",
- "gimli",
- "object 0.36.7",
- "target-lexicon 0.12.16",
- "wasmparser 0.221.3",
- "wasmtime-cranelift",
- "wasmtime-environ",
- "winch-codegen",
+ "windows-sys 0.61.2",
]
[[package]]
-name = "wasmtime-wit-bindgen"
-version = "28.0.1"
+name = "wasmtime-wasi-io"
+version = "43.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f38f7a5eb2f06f53fe943e7fb8bf4197f7cf279f1bc52c0ce56e9d3ffd750a4"
+checksum = "3ca5dd3b9f04a851c422d05f333366722742da46bff9369ae0191f32cf83565a"
dependencies = [
- "anyhow",
- "heck",
- "indexmap 2.13.0",
- "wit-parser 0.221.3",
+ "async-trait",
+ "bytes",
+ "futures",
+ "tracing",
+ "wasmtime",
]
[[package]]
@@ -9206,39 +9322,37 @@ dependencies = [
[[package]]
name = "wiggle"
-version = "28.0.1"
+version = "43.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3b23e3dc273d1e35cab9f38a5f76487aeeedcfa6a3fb594e209ee7b6f8b41dcc"
+checksum = "cc1b1135efc8e5a008971897bea8d41ca56d8d501d4efb807842ae0a1c78f639"
dependencies = [
- "anyhow",
- "async-trait",
"bitflags 2.11.0",
- "thiserror 1.0.69",
+ "thiserror 2.0.18",
"tracing",
"wasmtime",
+ "wasmtime-environ",
"wiggle-macro",
]
[[package]]
name = "wiggle-generate"
-version = "28.0.1"
+version = "43.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8738c5a7ef3a9de0fae10f8b84091a2aa4e059d8fef23de202ab689812b6bc6e"
+checksum = "a7bc2b0d50ec8773b44fbfe1da6cb5cc44a92deaf8483233dcf0831e6db33172"
dependencies = [
- "anyhow",
"heck",
"proc-macro2",
"quote",
- "shellexpand",
"syn 2.0.117",
+ "wasmtime-environ",
"witx",
]
[[package]]
name = "wiggle-macro"
-version = "28.0.1"
+version = "43.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e882267ac583e013a38a5aaeb83a49b219456ba3aa6e6772440f7213b176e8ff"
+checksum = "2d6c7d44ea552e1fbfdcd7a2cd83f5c2d1e803d5b1a11e3462c06888b77f455f"
dependencies = [
"proc-macro2",
"quote",
@@ -9279,19 +9393,21 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
[[package]]
name = "winch-codegen"
-version = "28.0.1"
+version = "43.0.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6232f40a795be2ce10fc761ed3b403825126a60d12491ac556ea104a932fd18a"
+checksum = "eb9f45f7172a2628c8317766e427babc0a400f9d10b1c0f0b0617c5ed5b79de6"
dependencies = [
- "anyhow",
+ "cranelift-assembler-x64",
"cranelift-codegen",
"gimli",
"regalloc2",
"smallvec",
- "target-lexicon 0.12.16",
- "wasmparser 0.221.3",
- "wasmtime-cranelift",
+ "target-lexicon",
+ "thiserror 2.0.18",
+ "wasmparser 0.245.1",
"wasmtime-environ",
+ "wasmtime-internal-core",
+ "wasmtime-internal-cranelift",
]
[[package]]
@@ -9695,9 +9811,9 @@ dependencies = [
[[package]]
name = "wit-parser"
-version = "0.221.3"
+version = "0.244.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "896112579ed56b4a538b07a3d16e562d101ff6265c46b515ce0c701eef16b2ac"
+checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"
dependencies = [
"anyhow",
"id-arena",
@@ -9708,16 +9824,17 @@ dependencies = [
"serde_derive",
"serde_json",
"unicode-xid",
- "wasmparser 0.221.3",
+ "wasmparser 0.244.0",
]
[[package]]
name = "wit-parser"
-version = "0.244.0"
+version = "0.245.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ecc8ac4bc1dc3381b7f59c34f00b67e18f910c2c0f50015669dde7def656a736"
+checksum = "330698718e82983499419494dd1e3d7811a457a9bf9f69734e8c5f07a2547929"
dependencies = [
"anyhow",
+ "hashbrown 0.16.1",
"id-arena",
"indexmap 2.13.0",
"log",
@@ -9726,7 +9843,7 @@ dependencies = [
"serde_derive",
"serde_json",
"unicode-xid",
- "wasmparser 0.244.0",
+ "wasmparser 0.245.1",
]
[[package]]
diff --git a/Cargo.toml b/Cargo.toml
index 0af78649186..4130032581a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,10 +1,11 @@
[workspace]
-members = [".", "crates/ironclaw_common", "crates/ironclaw_safety", "crates/ironclaw_skills", "crates/ironclaw_engine", "crates/ironclaw_tui"]
+members = [".", "crates/ironclaw_common", "crates/ironclaw_safety", "crates/ironclaw_skills", "crates/ironclaw_engine", "crates/ironclaw_gateway", "crates/ironclaw_tui"]
exclude = [
"channels-src/discord",
"channels-src/telegram",
"channels-src/slack",
"channels-src/whatsapp",
+ "tools-src/composio",
"tools-src/github",
"tools-src/gmail",
"tools-src/google-calendar",
@@ -116,6 +117,7 @@ ironclaw_common = { path = "crates/ironclaw_common", version = "0.1.0" }
# Safety/sanitization
ironclaw_engine = { path = "crates/ironclaw_engine", version = "0.1.0" }
+ironclaw_gateway = { path = "crates/ironclaw_gateway", version = "0.1.0" }
ironclaw_safety = { path = "crates/ironclaw_safety", version = "0.2.0" }
ironclaw_skills = { path = "crates/ironclaw_skills", version = "0.1.0" }
ironclaw_tui = { path = "crates/ironclaw_tui", version = "0.1.0", optional = true }
@@ -128,6 +130,7 @@ serde_yml = "0.0.12"
# Filesystem paths
dirs = "6"
fs4 = "0.6"
+glob = "0.3"
# Semantic versioning
semver = "1"
@@ -147,9 +150,9 @@ open = "5"
pgvector = { version = "0.4", features = ["postgres"], optional = true }
# WASM sandbox for untrusted tool execution
-wasmtime = { version = "28", features = ["component-model"] }
-wasmtime-wasi = "28" # WASI support for component model
-wasmparser = "0.220" # WASM binary parsing for validation
+wasmtime = { version = "43.0.1", features = ["component-model"] }
+wasmtime-wasi = "43.0.1" # WASI support for component model
+wasmparser = "0.245.1" # WASM binary parsing for validation
# Cryptography for secrets management
aes-gcm = "0.10"
@@ -226,7 +229,7 @@ tempfile = "3"
insta = "1.46.3"
[features]
-default = ["postgres", "libsql", "html-to-markdown"]
+default = ["postgres", "libsql", "html-to-markdown", "tui"]
postgres = [
"dep:deadpool-postgres",
"dep:tokio-postgres",
diff --git a/Dockerfile b/Dockerfile
index 89b9366597b..9c015e83317 100644
--- a/Dockerfile
+++ b/Dockerfile
@@ -32,6 +32,7 @@ COPY tests/ tests/
COPY migrations/ migrations/
COPY registry/ registry/
COPY channels-src/ channels-src/
+COPY tools-src/ tools-src/
COPY wit/ wit/
COPY providers.json providers.json
@@ -59,13 +60,59 @@ COPY tests/ tests/
COPY migrations/ migrations/
COPY registry/ registry/
COPY channels-src/ channels-src/
+COPY tools-src/ tools-src/
COPY wit/ wit/
COPY providers.json providers.json
+COPY profiles/ profiles/
RUN cargo build --profile dist --bin ironclaw
-# Stage 5: Minimal runtime
-FROM debian:bookworm-slim
+# Stage 4b: Build all WASM extensions from source (only used by runtime-staging)
+FROM builder AS wasm-builder
+ARG CACHE_BUST
+
+RUN apt-get update && apt-get install -y --no-install-recommends jq && rm -rf /var/lib/apt/lists/*
+RUN echo "cache-bust=${CACHE_BUST}"
+
+RUN set -eux; \
+ mkdir -p /app/wasm-bundles/tools /app/wasm-bundles/channels; \
+ for manifest in registry/tools/*.json registry/channels/*.json; do \
+ [ -f "$manifest" ] || continue; \
+ kind=$(jq -r '.kind' "$manifest"); \
+ ext_name=$(jq -r '.name' "$manifest"); \
+ source_dir=$(jq -r '.source.dir' "$manifest"); \
+ caps_file=$(jq -r '.source.capabilities' "$manifest"); \
+ crate_name=$(jq -r '.source.crate_name' "$manifest"); \
+ [ -d "$source_dir" ] || continue; \
+ # Telegram is embedded in the binary at build time; skip it
+ [ "$ext_name" = "telegram" ] && continue; \
+ echo "=== Building $ext_name from $source_dir ==="; \
+ if [ -f "$source_dir/Cargo.lock" ]; then \
+ CARGO_TARGET_DIR=/app/target cargo build --locked --release --target wasm32-wasip2 \
+ --manifest-path "$source_dir/Cargo.toml" || { echo "WARN: build failed for $ext_name"; continue; }; \
+ else \
+ CARGO_TARGET_DIR=/app/target cargo build --release --target wasm32-wasip2 \
+ --manifest-path "$source_dir/Cargo.toml" || { echo "WARN: build failed for $ext_name"; continue; }; \
+ fi; \
+ wasm_artifact=$(echo "${crate_name}" | tr '-' '_'); \
+ raw_wasm="/app/target/wasm32-wasip2/release/${wasm_artifact}.wasm"; \
+ [ -f "$raw_wasm" ] || continue; \
+ dest_dir="/app/wasm-bundles/tools"; \
+ [ "$kind" = "channel" ] && dest_dir="/app/wasm-bundles/channels"; \
+ wasm-tools component new "$raw_wasm" -o "$dest_dir/${ext_name}.wasm" 2>/dev/null \
+ || cp "$raw_wasm" "$dest_dir/${ext_name}.wasm"; \
+ wasm-tools strip "$dest_dir/${ext_name}.wasm" -o "$dest_dir/${ext_name}.wasm.tmp" 2>/dev/null \
+ && mv "$dest_dir/${ext_name}.wasm.tmp" "$dest_dir/${ext_name}.wasm" \
+ || true; \
+ [ -f "$source_dir/$caps_file" ] && cp "$source_dir/$caps_file" "$dest_dir/${ext_name}.capabilities.json"; \
+ echo " -> $dest_dir/${ext_name}.wasm"; \
+ done; \
+ count=$(find /app/wasm-bundles -name '*.wasm' | wc -l); \
+ echo "Built $count WASM extensions"; \
+ [ "$count" -gt 0 ] || { echo "ERROR: No WASM extensions were built"; exit 1; }
+
+# Stage 5a: Shared runtime base
+FROM debian:bookworm-slim AS runtime-base
RUN apt-get update \
&& apt-get install -y --no-install-recommends ca-certificates \
@@ -80,10 +127,19 @@ RUN useradd -m -d /home/ironclaw -u 1000 ironclaw \
&& mkdir -p /home/ironclaw/.ironclaw \
&& chown -R ironclaw:ironclaw /home/ironclaw
WORKDIR /home/ironclaw
-USER ironclaw
EXPOSE 3000
ENV RUST_LOG=ironclaw=info
ENTRYPOINT ["ironclaw"]
+
+# Stage 5b: Staging runtime (with pre-built WASM extensions)
+FROM runtime-base AS runtime-staging
+COPY --from=wasm-builder --chown=ironclaw:ironclaw /app/wasm-bundles/tools/ /home/ironclaw/.ironclaw/tools/
+COPY --from=wasm-builder --chown=ironclaw:ironclaw /app/wasm-bundles/channels/ /home/ironclaw/.ironclaw/channels/
+USER ironclaw
+
+# Stage 5c: Production runtime (default — no pre-bundled extensions)
+FROM runtime-base AS runtime
+USER ironclaw
diff --git a/crates/ironclaw_common/Cargo.toml b/crates/ironclaw_common/Cargo.toml
index 6e7db5a42df..2308ff9c417 100644
--- a/crates/ironclaw_common/Cargo.toml
+++ b/crates/ironclaw_common/Cargo.toml
@@ -13,5 +13,7 @@ repository = "https://github.com/nearai/ironclaw"
dist = false
[dependencies]
+chrono-tz = "0.10"
serde = { version = "1", features = ["derive"] }
serde_json = "1"
+tracing = "0.1"
diff --git a/crates/ironclaw_common/src/lib.rs b/crates/ironclaw_common/src/lib.rs
index c297342d65e..852374dfd4f 100644
--- a/crates/ironclaw_common/src/lib.rs
+++ b/crates/ironclaw_common/src/lib.rs
@@ -1,9 +1,11 @@
//! Shared types and utilities for the IronClaw workspace.
mod event;
+mod timezone;
mod util;
pub use event::{AppEvent, PlanStepDto, ToolDecisionDto};
+pub use timezone::{ValidTimezone, deserialize_option_lenient};
pub use util::truncate_preview;
/// Maximum worker agent loop iterations. Used by the orchestrator (server-side
diff --git a/crates/ironclaw_common/src/timezone.rs b/crates/ironclaw_common/src/timezone.rs
new file mode 100644
index 00000000000..4eea97421af
--- /dev/null
+++ b/crates/ironclaw_common/src/timezone.rs
@@ -0,0 +1,166 @@
+//! Validated IANA timezone type.
+
+use serde::{Deserialize, Serialize};
+
+/// A validated IANA timezone.
+///
+/// Wraps `chrono_tz::Tz` and guarantees the timezone string was valid at
+/// construction time. Use `ValidTimezone::parse()` to create — it returns
+/// `None` for empty or unrecognized timezone strings.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct ValidTimezone(chrono_tz::Tz);
+
+impl ValidTimezone {
+ /// Parse an IANA timezone string. Returns `None` for empty or invalid input.
+ pub fn parse(s: &str) -> Option {
+ let trimmed = s.trim();
+ if trimmed.is_empty() {
+ return None;
+ }
+ trimmed.parse::().ok().map(Self)
+ }
+
+ /// The underlying `chrono_tz::Tz` value.
+ pub fn tz(&self) -> chrono_tz::Tz {
+ self.0
+ }
+
+ /// The IANA name (e.g. "America/New_York").
+ pub fn name(&self) -> &str {
+ self.0.name()
+ }
+}
+
+impl std::fmt::Display for ValidTimezone {
+ fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+ f.write_str(self.name())
+ }
+}
+
+impl Serialize for ValidTimezone {
+ fn serialize(&self, serializer: S) -> Result {
+ self.name().serialize(serializer)
+ }
+}
+
+impl<'de> Deserialize<'de> for ValidTimezone {
+ fn deserialize>(deserializer: D) -> Result {
+ let s = String::deserialize(deserializer)?;
+ Self::parse(&s)
+ .ok_or_else(|| serde::de::Error::custom(format!("invalid IANA timezone: '{s}'")))
+ }
+}
+
+/// Lenient deserializer for `Option`.
+///
+/// Use with `#[serde(default, deserialize_with = "...")]` on fields that may
+/// contain invalid timezone strings from historical data. Invalid or empty
+/// values deserialize as `None` instead of failing the whole record. Each
+/// drop is logged at `debug!` so a typo in fresh user config is at least
+/// observable in the logs even though the record loads.
+pub fn deserialize_option_lenient<'de, D: serde::Deserializer<'de>>(
+ deserializer: D,
+) -> Result, D::Error> {
+ let opt: Option = Option::deserialize(deserializer)?;
+ match opt {
+ Some(s) => match ValidTimezone::parse(&s) {
+ Some(tz) => Ok(Some(tz)),
+ None => {
+ tracing::debug!(
+ raw = %s,
+ "lenient deserializer dropped invalid IANA timezone string to None"
+ );
+ Ok(None)
+ }
+ },
+ None => Ok(None),
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn parse_valid_timezone() {
+ let tz = ValidTimezone::parse("America/New_York").unwrap();
+ assert_eq!(tz.name(), "America/New_York");
+ }
+
+ #[test]
+ fn parse_with_whitespace() {
+ let tz = ValidTimezone::parse(" Europe/London ").unwrap();
+ assert_eq!(tz.name(), "Europe/London");
+ }
+
+ #[test]
+ fn parse_empty_returns_none() {
+ assert!(ValidTimezone::parse("").is_none());
+ assert!(ValidTimezone::parse(" ").is_none());
+ }
+
+ #[test]
+ fn parse_invalid_returns_none() {
+ assert!(ValidTimezone::parse("NotATimezone").is_none());
+ assert!(ValidTimezone::parse("US/FakeCity").is_none());
+ }
+
+ #[test]
+ fn serde_roundtrip() {
+ let tz = ValidTimezone::parse("Asia/Tokyo").unwrap();
+ let json = serde_json::to_string(&tz).unwrap();
+ assert_eq!(json, "\"Asia/Tokyo\"");
+ let back: ValidTimezone = serde_json::from_str(&json).unwrap();
+ assert_eq!(back, tz);
+ }
+
+ #[test]
+ fn deserialize_invalid_fails() {
+ let result: Result = serde_json::from_str("\"NotReal\"");
+ assert!(result.is_err());
+ }
+
+ #[test]
+ fn lenient_deserialize_valid() {
+ #[derive(serde::Deserialize)]
+ struct T {
+ #[serde(default, deserialize_with = "super::deserialize_option_lenient")]
+ tz: Option,
+ }
+ let t: T = serde_json::from_str(r#"{"tz":"America/Chicago"}"#).unwrap();
+ assert_eq!(t.tz.unwrap().name(), "America/Chicago");
+ }
+
+ #[test]
+ fn lenient_deserialize_invalid_becomes_none() {
+ #[derive(serde::Deserialize)]
+ struct T {
+ #[serde(default, deserialize_with = "super::deserialize_option_lenient")]
+ tz: Option,
+ }
+ let t: T = serde_json::from_str(r#"{"tz":"NotReal"}"#).unwrap();
+ assert!(t.tz.is_none(), "invalid timezone should become None");
+ }
+
+ #[test]
+ fn lenient_deserialize_null_becomes_none() {
+ #[derive(serde::Deserialize)]
+ struct T {
+ #[serde(default, deserialize_with = "super::deserialize_option_lenient")]
+ tz: Option,
+ }
+ let t: T = serde_json::from_str(r#"{"tz":null}"#).unwrap();
+ assert!(t.tz.is_none());
+ }
+
+ #[test]
+ fn lenient_deserialize_missing_becomes_none() {
+ #[derive(serde::Deserialize)]
+ struct T {
+ #[serde(default, deserialize_with = "super::deserialize_option_lenient")]
+ tz: Option,
+ }
+ let t: T = serde_json::from_str(r#"{}"#).unwrap();
+ assert!(t.tz.is_none());
+ }
+}
diff --git a/crates/ironclaw_engine/Cargo.toml b/crates/ironclaw_engine/Cargo.toml
index 77f5ccba85e..726b59a3a19 100644
--- a/crates/ironclaw_engine/Cargo.toml
+++ b/crates/ironclaw_engine/Cargo.toml
@@ -15,6 +15,8 @@ dist = false
[dependencies]
async-trait = "0.1"
+cron = "0.13"
+ironclaw_common = { path = "../ironclaw_common", version = "0.1.0" }
ironclaw_skills = { path = "../ironclaw_skills", version = "0.1.0", default-features = false }
chrono = { version = "0.4", features = ["serde"] }
monty = { git = "https://github.com/pydantic/monty.git", rev = "7a0d4b75b72e6ddacafaf36e26486186cdb6eb68" }
diff --git a/crates/ironclaw_engine/orchestrator/default.py b/crates/ironclaw_engine/orchestrator/default.py
index ee701f4d7c2..ef8a7a82f93 100644
--- a/crates/ironclaw_engine/orchestrator/default.py
+++ b/crates/ironclaw_engine/orchestrator/default.py
@@ -16,6 +16,9 @@
# __retrieve_docs__(goal, max_docs) -> list of doc dicts
# __check_budget__() -> budget dict
# __get_actions__() -> list of action dicts
+# __list_skills__() -> list of skill dicts
+# __record_skill_usage__(doc_id, success) -> None
+# __regex_match__(pattern, text) -> bool
#
# Context variables (injected by Rust before execution):
# context - list of prior messages [{role, content}]
@@ -182,6 +185,14 @@ def format_docs(docs):
return "\n".join(parts)
+# Conservative fallback heuristic matching the old Rust-side estimator.
+# These MUST be defined before `estimate_context_tokens` (and therefore
+# before the `FINAL(result)` entry-point call below). Moving them after the
+# entry point is a latent NameError every time `compact_if_needed` runs.
+CHARS_PER_TOKEN = 4
+MESSAGE_OVERHEAD_CHARS = 4
+
+
def estimate_context_tokens(messages):
"""Estimate token count for a transcript using a rough chars/token heuristic."""
total_chars = 0
@@ -268,8 +279,15 @@ def compact_if_needed(state, config):
# ── Skill selection and injection (self-modifiable) ────────
-def score_skill(skill, message_lower):
- """Score a skill against a user message. Returns 0 if vetoed."""
+def score_skill(skill, message_lower, message_original):
+ """Score a skill against a user message. Returns 0 if vetoed.
+
+ Scoring is aligned with the v1 `ironclaw_skills::selector::score_skill`:
+ - exclude_keyword veto: any match => score 0
+ - keyword: exact word = 10, substring = 5 (cap 30)
+ - tag: substring = 3 (cap 15)
+ - regex pattern: each match = 20 (cap 40)
+ """
meta = skill.get("metadata", {})
activation = meta.get("activation", {})
@@ -282,7 +300,11 @@ def score_skill(skill, message_lower):
# Keyword scoring: exact word = 10, substring = 5 (cap 30)
kw_score = 0
- words = message_lower.split()
+ words = []
+ for word in message_lower.split():
+ trimmed = word.strip(".,!?;:'\"()[]{}<>`~@#$%^&*-_=+/\\|")
+ if trimmed:
+ words.append(trimmed)
for kw in activation.get("keywords", []):
kw_lower = kw.lower()
if kw_lower in words:
@@ -298,6 +320,14 @@ def score_skill(skill, message_lower):
tag_score += 3
score += min(tag_score, 15)
+ # Regex pattern scoring: each match = 20 (cap 40). Monty has no `re`
+ # module, so we call out to a host function that uses Rust's regex crate.
+ rx_score = 0
+ for pat in activation.get("patterns", []):
+ if __regex_match__(str(pat), message_original):
+ rx_score += 20
+ score += min(rx_score, 40)
+
# Confidence factor for extracted skills
source = meta.get("source", "authored")
if source == "extracted":
@@ -316,9 +346,10 @@ def select_skills(skills, goal, max_candidates=3, max_tokens=4000):
return []
message_lower = goal.lower()
+ message_original = goal
scored = []
for skill in skills:
- s = score_skill(skill, message_lower)
+ s = score_skill(skill, message_lower, message_original)
if s > 0:
scored.append((s, skill))
@@ -644,22 +675,56 @@ def run_loop(context, goal, actions, state, config):
# NOTE: consecutive_nudges is NOT reset here (V1 semantics).
# Only non-intent text responses reset the counter.
calls = response.get("calls", [])
+
+ # Handle FINAL emitted as a structured tool call. FINAL is a
+ # CodeAct sentinel for completion — when the LLM tries to call
+ # it via tool_calls instead of inside a code block, the engine's
+ # action executor has no lease for it and the call fails. If FINAL
+ # is co-emitted with other calls, execute the non-FINAL calls first
+ # so persistence side effects are not silently dropped.
+ final_call = None
+ duplicate_finals_dropped = 0
+ executable_calls = []
+ for c in calls:
+ if c.get("name", "") == "FINAL":
+ # First FINAL wins; any extras are dropped (not appended
+ # to executable_calls) so they don't try to run as a
+ # normal action and fail with a lease error.
+ if final_call is None:
+ final_call = c
+ else:
+ duplicate_finals_dropped += 1
+ continue
+ executable_calls.append(c)
+
+ if duplicate_finals_dropped > 0:
+ # Surface the drop so traces show why fewer FINALs were
+ # executed than the LLM emitted.
+ __emit_event__(
+ "duplicate_final_dropped",
+ count=duplicate_finals_dropped,
+ )
+
+ # Append the assistant message with only the executable calls.
+ # FINAL is filtered out of `action_calls` so the message history
+ # does not record a FINAL action with no matching ActionResult,
+ # which would confuse context replay on resume.
append_message(
working_messages,
"Assistant",
response.get("content", "") or "",
- action_calls=calls,
+ action_calls=executable_calls,
)
# Execute all tool calls in parallel via the batch host function.
# Rust handles preflight (lease/policy), parallel execution via
# JoinSet, and event emission in call order.
- results = __execute_actions_parallel__(calls)
+ results = __execute_actions_parallel__(executable_calls)
for idx in range(len(results)):
r = results[idx]
if r is None:
continue
- call = calls[idx] if idx < len(calls) else {}
+ call = executable_calls[idx] if idx < len(executable_calls) else {}
call_id = call.get("call_id", "")
action_name = r.get("action_name", call.get("name", ""))
output = r.get("output")
@@ -686,7 +751,7 @@ def run_loop(context, goal, actions, state, config):
})
gate = r
# Get action info from the original call or the result
- orig_call = calls[r_idx] if r_idx < len(calls) else {}
+ orig_call = executable_calls[r_idx] if r_idx < len(executable_calls) else {}
__transition_to__("waiting", "gate paused: " + gate.get("gate_name", "unknown"))
return {
"outcome": "gate_paused",
@@ -729,6 +794,48 @@ def run_loop(context, goal, actions, state, config):
"parameters": r.get("parameters", {}),
}
+ if final_call is not None:
+ raw_params = final_call.get("params", {})
+ # Some LLMs pass FINAL with the answer as a positional string
+ # argument instead of a named param dict. Handle that case so
+ # the answer is not silently dropped.
+ if isinstance(raw_params, str):
+ answer = raw_params
+ else:
+ params = raw_params or {}
+ answer = (
+ params.get("answer")
+ or params.get("result")
+ or params.get("value")
+ or params.get("content")
+ or params.get("text")
+ )
+ if not answer:
+ # Fall back to the assistant's content text. This may
+ # contain the model's full explanation rather than the
+ # intended terse answer — truncate aggressively so we
+ # don't ship thousands of tokens of reasoning as the
+ # final answer, and emit a trace event so the
+ # ambiguity is visible.
+ fallback_content = response.get("content", "") or ""
+ FINAL_FALLBACK_MAX_CHARS = 500
+ truncated = False
+ if len(fallback_content) > FINAL_FALLBACK_MAX_CHARS:
+ fallback_content = (
+ fallback_content[:FINAL_FALLBACK_MAX_CHARS]
+ + "… [truncated by orchestrator: FINAL was emitted with no recognizable answer param]"
+ )
+ truncated = True
+ answer = fallback_content
+ __emit_event__(
+ "final_fallback",
+ reason="no recognizable answer param on FINAL",
+ truncated=truncated,
+ original_length=len(response.get("content", "") or ""),
+ )
+ __transition_to__("completed", "FINAL via tool_calls")
+ return complete_result(state, "completed", str(answer))
+
__save_checkpoint__(state, {
"nudge_count": consecutive_nudges,
"consecutive_errors": consecutive_errors,
@@ -743,6 +850,3 @@ def run_loop(context, goal, actions, state, config):
# Entry point: call run_loop with injected context variables
result = run_loop(context, goal, actions, state, config)
FINAL(result)
-# Conservative fallback heuristic matching the old Rust-side estimator.
-CHARS_PER_TOKEN = 4
-MESSAGE_OVERHEAD_CHARS = 4
diff --git a/crates/ironclaw_engine/prompts/codeact_preamble.md b/crates/ironclaw_engine/prompts/codeact_preamble.md
index 96cce1d5bfb..b124d7500f6 100644
--- a/crates/ironclaw_engine/prompts/codeact_preamble.md
+++ b/crates/ironclaw_engine/prompts/codeact_preamble.md
@@ -33,7 +33,7 @@ This is much faster than calling tools sequentially. Use `asyncio.gather()` when
- `llm_query_batched(prompts, context=None)` — Same but for multiple prompts in parallel. Returns a list of strings.
- `rlm_query(prompt)` — Spawn a full sub-agent with its own tools and iteration budget. Use for complex sub-tasks that need tool access. Returns the sub-agent's final answer as a string. More powerful but more expensive than llm_query.
- `FINAL(answer)` — Call this when you have the final answer. The argument is returned to the user.
-- `mission_create(name, goal, cadence="manual", success_criteria=None)` — Create a long-running mission that spawns threads over time. Cadence: "manual", cron expression (e.g. "0 9 * * *"), "event:pattern", or "webhook:path". Returns {"mission_id": "...", "name": "...", "status": "created"}. When telling the user about a created mission, refer to it by `name`, not by `mission_id` (the UUID is internal).
+- `mission_create(name, goal, cadence="manual", success_criteria=None)` — Create a long-running mission that spawns threads over time. Cadence: "manual", cron expression (e.g. "0 9 * * *"), "event:pattern", or "webhook:path". Cron expressions accept 5-field (`min hr dom mon dow`), 6-field (`sec min hr dom mon dow` — NOT Quartz-style with year), or 7-field (`sec min hr dom mon dow year`). Cron missions default to the user's timezone from `user_timezone`; pass an explicit `timezone` param to override. Returns {"mission_id": "...", "name": "...", "status": "created"}. When telling the user about a created mission, refer to it by `name`, not by `mission_id` (the UUID is internal).
- `mission_list()` — List all missions with their status, goal, and current focus.
- `mission_fire(id)` — Manually trigger a mission to spawn a thread now.
- `mission_pause(id)` / `mission_resume(id)` — Pause or resume a mission.
@@ -45,6 +45,7 @@ This is much faster than calling tools sequentially. Use `asyncio.gather()` when
- `step_number` — Current execution step
- `state` — Dict of persisted data from previous steps. Contains tool results keyed by tool name (e.g. `state['web_search']`) and return values (`state['last_return']`, `state['step_0_return']`). Use this to access data from previous steps without re-calling tools.
- `previous_results` — Dict of prior tool call results (from ActionResult messages)
+- `user_timezone` — The user's IANA timezone (e.g. "America/New_York", "Europe/London"). Defaults to "UTC". Use this for time-aware operations, scheduling, and cron timezone parameters.
## Important rules
diff --git a/crates/ironclaw_engine/src/executor/loop_engine.rs b/crates/ironclaw_engine/src/executor/loop_engine.rs
index 57325052a8d..f7fd43ae91e 100644
--- a/crates/ironclaw_engine/src/executor/loop_engine.rs
+++ b/crates/ironclaw_engine/src/executor/loop_engine.rs
@@ -617,7 +617,11 @@ mod tests {
let outcome = exec.run().await.unwrap();
assert!(matches!(outcome, ThreadOutcome::Completed { response: Some(r) } if r == "Done!"));
assert_eq!(exec.thread.step_count, 2);
- // Orchestrator stores working messages in internal_messages
+ // Orchestrator-driven flow: working messages live in `internal_messages`
+ // (set by `sync_runtime_state` when the orchestrator persists state),
+ // while `thread.messages` only carries the system prompt + final
+ // assistant response. The full conversation transcript (system,
+ // assistant+actions, action_result, assistant) is in internal_messages.
assert!(exec.thread.internal_messages.len() >= 3);
}
@@ -735,7 +739,9 @@ mod tests {
matches!(outcome, ThreadOutcome::Completed { response: Some(r) } if r == "The answer is 42")
);
assert_eq!(exec.thread.step_count, 2);
- // Nudge is stored in orchestrator's working messages (internal transcript)
+ // Nudge is injected into the orchestrator's working messages, which
+ // are persisted as `thread.internal_messages` (not the user-visible
+ // `messages` transcript).
assert!(
exec.thread
.internal_messages
@@ -873,7 +879,8 @@ mod tests {
matches!(outcome, ThreadOutcome::Completed { response: Some(r) } if r == "done, x was 30")
);
assert_eq!(exec.thread.step_count, 2);
- // The output metadata from first step should be in internal messages
+ // The first step's stdout/output metadata is persisted as part of
+ // the orchestrator's working messages → `internal_messages`.
assert!(
exec.thread
.internal_messages
diff --git a/crates/ironclaw_engine/src/executor/orchestrator.rs b/crates/ironclaw_engine/src/executor/orchestrator.rs
index 3a58ea86c53..2797453ee4a 100644
--- a/crates/ironclaw_engine/src/executor/orchestrator.rs
+++ b/crates/ironclaw_engine/src/executor/orchestrator.rs
@@ -42,8 +42,9 @@ use crate::types::event::{EventKind, ThreadEvent, summarize_params};
use crate::types::message::ThreadMessage;
use crate::types::project::ProjectId;
use crate::types::shared_owner_id;
-use crate::types::step::{StepId, TokenUsage};
+use crate::types::step::{ActionCall, StepId, TokenUsage};
use crate::types::thread::{ActiveSkillProvenance, Thread, ThreadState};
+use ironclaw_common::ValidTimezone;
use super::scripting::{execute_code, json_to_monty, monty_to_json, monty_to_string};
@@ -73,6 +74,15 @@ fn thread_source_channel(thread: &Thread) -> Option {
.map(String::from)
}
+/// Extract and validate user_timezone from thread metadata (set by bridge router).
+fn thread_user_timezone(thread: &Thread) -> Option {
+ thread
+ .metadata
+ .get("user_timezone")
+ .and_then(|v| v.as_str())
+ .and_then(ValidTimezone::parse)
+}
+
fn normalize_pause_outcome(
thread: &mut Thread,
outcome: &ThreadOutcome,
@@ -477,6 +487,13 @@ pub async fn execute_orchestrator(
// __record_skill_usage__(doc_id, success)
"__record_skill_usage__" => handle_record_skill_usage(args, store).await,
+ // __regex_match__(pattern, text) -> bool
+ // Evaluates a regex against text using Rust's regex crate.
+ // Invalid patterns return False silently. Monty has no `re`
+ // module, so this host function bridges the gap for the
+ // skill selector's pattern-based scoring.
+ "__regex_match__" => handle_regex_match(args),
+
// __set_active_skills__(skills)
"__set_active_skills__" => handle_set_active_skills(args, thread),
@@ -635,16 +652,9 @@ async fn handle_llm_complete(
serde_json::json!({"type": "code", "code": code, "usage": usage})
}
LlmResponse::ActionCalls { calls, content } => {
- let calls_json: Vec = calls
- .iter()
- .map(|c| {
- serde_json::json!({
- "name": c.action_name,
- "call_id": c.id,
- "params": c.parameters,
- })
- })
- .collect();
+ // Single source of truth for the Python interchange
+ // shape — must round-trip via `python_json_to_action_calls`.
+ let calls_json = action_calls_to_python_json(&calls);
serde_json::json!({
"type": "actions",
"content": content,
@@ -701,6 +711,7 @@ async fn handle_execute_code_step(
step_id: StepId::new(),
current_call_id: None,
source_channel: thread_source_channel(thread),
+ user_timezone: thread_user_timezone(thread),
};
// Run user code in a nested Monty VM (same pattern as rlm_query)
@@ -728,6 +739,37 @@ async fn handle_execute_code_step(
}
thread.events.push(event);
}
+ // If the CodeAct snippet itself failed (Python SyntaxError, runtime
+ // error, etc.), surface it as an ActionFailed event so traces and
+ // observers see the failure. Without this, parse errors silently
+ // fall back to the LLM via the result dict and never warn callers.
+ if result.had_error {
+ let error_msg = if !result.stdout.is_empty() {
+ let snippet: String = result.stdout.chars().take(500).collect();
+ format!("CodeAct execution failed: {snippet}")
+ } else {
+ "CodeAct execution failed (no stdout)".to_string()
+ };
+ let failed_event = ThreadEvent::new(
+ thread.id,
+ EventKind::ActionFailed {
+ step_id: exec_ctx.step_id,
+ action_name: "__codeact__".to_string(),
+ // Synthetic call_id derived from the step id —
+ // CodeAct snippet failures don't have an LLM-provided
+ // call_id, but `loop_engine.rs:1277` asserts that
+ // ActionFailed events carry a non-empty call_id for
+ // trace correlation.
+ call_id: format!("codeact-step-{}", exec_ctx.step_id.0),
+ error: error_msg,
+ params_summary: None,
+ },
+ );
+ if let Some(tx) = event_tx {
+ let _ = tx.send(failed_event.clone());
+ }
+ thread.events.push(failed_event);
+ }
thread.updated_at = chrono::Utc::now();
let action_results: Vec = result
@@ -819,6 +861,7 @@ async fn handle_execute_action(
step_id: StepId::new(),
current_call_id: Some(call_id.clone()),
source_channel: thread_source_channel(thread),
+ user_timezone: thread_user_timezone(thread),
};
// Helper: emit event only. The orchestrator owns transcript recording.
@@ -930,32 +973,88 @@ async fn handle_execute_action(
}
}
- // 3. Consume a lease use
- if let Err(e) = leases.consume_use(lease.id).await {
- debug!(error = %e, "lease consumption failed (non-fatal)");
- }
-
- // 4. Execute
- let ps = summarize_params(&name, ¶ms);
- match effects
- .execute_action(&name, params, &lease, &exec_ctx)
- .await
- {
- Ok(r) => {
+ // 3. Atomically re-find + consume a lease use under a single write
+ // lock. This closes the TOCTOU window between the read-only
+ // `find_lease_for_action` (used above for the policy check) and the
+ // consume — without it, two concurrent calls could both observe a
+ // lease with one remaining use and both proceed to execute. Mirrors
+ // `structured.rs::execute_action_batch_with_results`.
+ let lease = match leases.find_and_consume(thread.id, &name).await {
+ Ok(l) => l,
+ Err(e) => {
+ debug!(error = %e, "atomic lease find_and_consume failed");
+ let error = format!("lease consumption failed for action '{name}': {e}");
+ let output = serde_json::json!({"error": &error});
emit_and_record(
thread,
event_tx,
- EventKind::ActionExecuted {
+ EventKind::ActionFailed {
step_id: exec_ctx.step_id,
action_name: name.clone(),
call_id: call_id.clone(),
- duration_ms: r.duration.as_millis() as u64,
- params_summary: ps.clone(),
+ error,
+ params_summary: None,
},
&call_id,
&name,
- &r.output,
+ &output,
);
+ let result = serde_json::json!({
+ "output": output,
+ "is_error": true,
+ });
+ return ExtFunctionResult::Return(json_to_monty(&result));
+ }
+ };
+
+ // 4. Execute
+ let ps = summarize_params(&name, ¶ms);
+ match effects
+ .execute_action(&name, params, &lease, &exec_ctx)
+ .await
+ {
+ Ok(r) => {
+ // Effect adapters wrap tool errors as `Ok(ActionResult { is_error: true })`
+ // — surface them as `ActionFailed` so traces and observers see the
+ // failure. See `resolve_tool_future` in `scripting.rs` for the same
+ // pattern on the structured-tool path.
+ if r.is_error {
+ let error_msg = r
+ .output
+ .get("error")
+ .and_then(|v| v.as_str())
+ .map(String::from)
+ .unwrap_or_else(|| r.output.to_string());
+ emit_and_record(
+ thread,
+ event_tx,
+ EventKind::ActionFailed {
+ step_id: exec_ctx.step_id,
+ action_name: name.clone(),
+ call_id: call_id.clone(),
+ error: error_msg,
+ params_summary: ps.clone(),
+ },
+ &call_id,
+ &name,
+ &r.output,
+ );
+ } else {
+ emit_and_record(
+ thread,
+ event_tx,
+ EventKind::ActionExecuted {
+ step_id: exec_ctx.step_id,
+ action_name: name.clone(),
+ call_id: call_id.clone(),
+ duration_ms: r.duration.as_millis() as u64,
+ params_summary: ps.clone(),
+ },
+ &call_id,
+ &name,
+ &r.output,
+ );
+ }
let result = serde_json::json!({
"action_name": r.action_name,
"output": r.output,
@@ -1226,10 +1325,35 @@ async fn handle_execute_actions_parallel(
}
}
- // Consume lease
- if let Err(e) = leases.consume_use(lease.id).await {
- debug!(error = %e, "lease consumption failed (non-fatal)");
- }
+ // Atomically re-find + consume a lease use under a single write
+ // lock, closing the TOCTOU window between the read-only
+ // `find_lease_for_action` above and the consume. Mirrors
+ // `structured.rs::execute_action_batch_with_results`.
+ let lease = match leases.find_and_consume(thread.id, &pc.name).await {
+ Ok(l) => l,
+ Err(e) => {
+ debug!(error = %e, "atomic lease find_and_consume failed");
+ let error = format!("lease consumption failed for action '{}': {e}", pc.name);
+ let output = serde_json::json!({"error": &error});
+ let result_json = serde_json::json!({
+ "output": &output,
+ "is_error": true,
+ });
+ let event = EventKind::ActionFailed {
+ step_id,
+ action_name: pc.name.clone(),
+ call_id: pc.call_id.clone(),
+ error,
+ params_summary: None,
+ };
+ preflight.push(Some(PfOutcome::Error {
+ result_json,
+ event,
+ output,
+ }));
+ continue;
+ }
+ };
preflight.push(Some(PfOutcome::Runnable { lease }));
}
@@ -1278,6 +1402,7 @@ async fn handle_execute_actions_parallel(
// silently dropped the gateway routing for any tool dispatched
// through the parallel batch path.
source_channel: thread_source_channel(thread),
+ user_timezone: thread_user_timezone(thread),
};
let ps = summarize_params(&pc.name, &pc.params);
let (result_json, event, output) = execute_single_action(
@@ -1303,6 +1428,7 @@ async fn handle_execute_actions_parallel(
// Capture once outside the loop — the thread's metadata is stable
// for the duration of the parallel batch.
let parallel_source_channel = thread_source_channel(thread);
+ let parallel_user_timezone = thread_user_timezone(thread);
for (idx, lease) in runnable {
let pc_name = parsed[idx].name.clone();
@@ -1319,6 +1445,7 @@ async fn handle_execute_actions_parallel(
current_call_id: Some(pc_call_id.clone()),
// See comment above — read from thread metadata, not None.
source_channel: parallel_source_channel.clone(),
+ user_timezone: parallel_user_timezone,
};
let ps = summarize_params(&pc_name, &pc_params);
@@ -1393,12 +1520,30 @@ async fn execute_single_action(
) -> (serde_json::Value, EventKind, serde_json::Value) {
match effects.execute_action(name, params, lease, exec_ctx).await {
Ok(r) => {
- let event = EventKind::ActionExecuted {
- step_id: exec_ctx.step_id,
- action_name: name.to_string(),
- call_id: call_id.to_string(),
- duration_ms: r.duration.as_millis() as u64,
- params_summary: params_summary.clone(),
+ // Surface wrapped errors as ActionFailed (see resolve_tool_future
+ // and the parallel execute path for the same pattern).
+ let event = if r.is_error {
+ let error_msg = r
+ .output
+ .get("error")
+ .and_then(|v| v.as_str())
+ .map(String::from)
+ .unwrap_or_else(|| r.output.to_string());
+ EventKind::ActionFailed {
+ step_id: exec_ctx.step_id,
+ action_name: name.to_string(),
+ call_id: call_id.to_string(),
+ error: error_msg,
+ params_summary: params_summary.clone(),
+ }
+ } else {
+ EventKind::ActionExecuted {
+ step_id: exec_ctx.step_id,
+ action_name: name.to_string(),
+ call_id: call_id.to_string(),
+ duration_ms: r.duration.as_millis() as u64,
+ params_summary: params_summary.clone(),
+ }
};
let result_json = serde_json::json!({
"action_name": r.action_name,
@@ -1816,6 +1961,50 @@ async fn handle_record_skill_usage(
ExtFunctionResult::Return(MontyObject::None)
}
+/// Handle `__regex_match__(pattern, text) -> bool`.
+///
+/// Compiles `pattern` with a bounded size limit and returns whether it
+/// matches anywhere in `text`. Invalid regex or a size-limit violation
+/// returns `False` silently. Used by the Python skill selector for regex
+/// pattern scoring (Monty has no `re` module).
+///
+/// **Security: ReDoS safety.** This handler accepts arbitrary patterns from
+/// the Python orchestrator (which itself receives them from skill manifests)
+/// and runs them on user-supplied text. Safety relies on the `regex` crate's
+/// linear-time matching guarantee (no backreferences, no lookaround) plus the
+/// 64 KiB compiled-size cap and DFA-size cap below. If the `regex` crate is
+/// ever swapped for `fancy-regex` (which supports backreferences and is NOT
+/// linear-time), this becomes a real ReDoS vector. This is enforced by
+/// convention and documentation only — see the top-of-crate comment in
+/// `crates/ironclaw_engine/src/lib.rs`. (A `#[cfg(feature = "fancy-regex")]
+/// compile_error!` tripwire was evaluated but conflicts with
+/// `cargo clippy --all-features` which is the standard CI command.)
+fn handle_regex_match(args: &[MontyObject]) -> ExtFunctionResult {
+ let pattern = args.first().map(monty_to_string).unwrap_or_default();
+ let text = args.get(1).map(monty_to_string).unwrap_or_default();
+ if pattern.is_empty() {
+ return ExtFunctionResult::Return(MontyObject::Bool(false));
+ }
+ // Cap compiled regex size to prevent ReDoS (matches the 64 KiB limit used
+ // by `LoadedSkill::compile_patterns` in `ironclaw_skills`). Also cap the
+ // lazy-DFA cache: the `regex` crate's DFA can grow beyond `size_limit`
+ // during matching, so `dfa_size_limit` is a separate defensive cap on
+ // memory allocation from a crafted pattern over untrusted skill manifests.
+ const MAX_REGEX_SIZE: usize = 1 << 16;
+ let matched = match regex::RegexBuilder::new(&pattern)
+ .size_limit(MAX_REGEX_SIZE)
+ .dfa_size_limit(MAX_REGEX_SIZE)
+ .build()
+ {
+ Ok(re) => re.is_match(&text),
+ Err(e) => {
+ debug!("__regex_match__: invalid pattern '{pattern}': {e}");
+ false
+ }
+ };
+ ExtFunctionResult::Return(MontyObject::Bool(matched))
+}
+
/// Handle `__set_active_skills__(skills)`.
///
/// Persists the selected skill provenance onto the thread so post-run learning
@@ -1866,12 +2055,27 @@ fn build_orchestrator_inputs(
let context: Vec = bootstrap_messages
.iter()
.map(|m| {
+ // Serialize action_calls through the Python interchange shape
+ // (`{name, call_id, params}`) so the bootstrap context is
+ // round-trip compatible with `python_json_to_action_calls`.
+ // Using bare `m.action_calls` here produces the canonical Rust
+ // serde format (`{action_name, id, parameters}`), which the
+ // Python orchestrator passes back verbatim on the next
+ // `__llm_complete__` call — and `python_json_to_action_calls`
+ // then fails with "missing field `name`", orphaning every
+ // subsequent tool result. This is the SECOND code path (after
+ // `handle_llm_complete`) that feeds action_calls into the
+ // Python working transcript; both must use the same shape.
+ let calls_json = m
+ .action_calls
+ .as_ref()
+ .map(|calls| serde_json::Value::Array(action_calls_to_python_json(calls)));
serde_json::json!({
"role": format!("{:?}", m.role),
"content": m.content,
"action_name": m.action_name,
"action_call_id": m.action_call_id,
- "action_calls": m.action_calls,
+ "action_calls": calls_json,
})
})
.collect();
@@ -1903,6 +2107,164 @@ fn build_orchestrator_inputs(
(names, values)
}
+/// JSON shape used to interchange `ActionCall`s with the Python orchestrator.
+///
+/// This is the *single* place that defines the field naming convention used
+/// across the Python boundary. It is intentionally separate from the
+/// canonical `ActionCall` type because:
+///
+/// - `ActionCall` uses Rust-idiomatic field names (`id`, `action_name`,
+/// `parameters`) and is also persisted into Step records and ThreadEvents.
+/// Renaming its serde fields would invalidate every existing row.
+/// - The Python orchestrator uses friendlier names (`call_id`, `name`,
+/// `params`) that read naturally in CodeAct prompts and `default.py`.
+///
+/// Without this type, the round-trip is asymmetric: Rust → Python uses one
+/// shape, Python → Rust used `serde_json::from_value::>`
+/// which silently fails (`.ok()` swallows the error) and produces `None`,
+/// which means assistant messages came back without `action_calls`. The
+/// downstream effect is that every tool result looks orphaned to
+/// `sanitize_tool_messages` and gets rewritten as a user message — losing
+/// the assistant ↔ tool_result linkage the LLM needs to reason about prior
+/// tool calls.
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+struct PythonActionCall {
+ name: String,
+ call_id: String,
+ params: serde_json::Value,
+}
+
+impl From<&ActionCall> for PythonActionCall {
+ fn from(c: &ActionCall) -> Self {
+ Self {
+ name: c.action_name.clone(),
+ call_id: c.id.clone(),
+ params: c.parameters.clone(),
+ }
+ }
+}
+
+impl From for ActionCall {
+ fn from(p: PythonActionCall) -> Self {
+ Self {
+ id: p.call_id,
+ action_name: p.name,
+ parameters: p.params,
+ }
+ }
+}
+
+/// Serialize a slice of `ActionCall`s into the Python interchange shape.
+///
+/// On serialization failure (essentially unreachable for `String + String +
+/// Value`, but still possible if the `serde_json::Value` parameters tree
+/// contains a key whose stringification fails), the entry is **dropped**
+/// from the output rather than replaced with `Value::Null`. The previous
+/// `unwrap_or_else(|_| Value::Null)` corrupted the array — Python's
+/// `default.py` accesses `c.get("name")` / `c.get("call_id")` /
+/// `c.get("params")` on each entry, so a `null` would crash with a Python
+/// `AttributeError` and lose the entire LLM step. `filter_map` produces a
+/// shorter array, which Python's tool-result loop handles correctly because
+/// it iterates `range(len(results))` against the shortened call list. The
+/// warn log is preserved so operators have a breadcrumb if it ever fires.
+fn action_calls_to_python_json(calls: &[ActionCall]) -> Vec {
+ calls
+ .iter()
+ .filter_map(|c| match serde_json::to_value(PythonActionCall::from(c)) {
+ Ok(value) => Some(value),
+ Err(e) => {
+ warn!(
+ error = %e,
+ action_name = %c.action_name,
+ "Failed to serialize ActionCall for Python orchestrator — dropping entry"
+ );
+ None
+ }
+ })
+ .collect()
+}
+
+/// Build a PII-safe summary of an `action_calls` JSON value for log output.
+///
+/// The action_calls payload contains tool parameters, which can carry user
+/// PII (search queries, file names, email content, conversation text).
+/// Dumping the full value into a `warn!` log would leak that PII to log
+/// aggregation systems (Datadog, CloudWatch, Sentry) the moment the parser
+/// fails — and the parser only fails when the Python ↔ Rust shape drifts,
+/// which is exactly when an operator is most likely to be grepping logs.
+///
+/// We emit only the structural information operators actually need to
+/// debug a shape drift: array length and the keys of the first entry. The
+/// keys themselves are not user data — they're field names like
+/// `name`/`call_id`/`params` that are static across all calls.
+fn summarize_action_calls_for_log(value: &serde_json::Value) -> String {
+ match value.as_array() {
+ Some(arr) if arr.is_empty() => "empty array".to_string(),
+ Some(arr) => {
+ let first_keys = arr
+ .first()
+ .and_then(|v| v.as_object())
+ .map(|obj| {
+ let mut keys: Vec<&str> = obj.keys().map(String::as_str).collect();
+ keys.sort_unstable();
+ keys.join(",")
+ })
+ .unwrap_or_else(|| "".to_string());
+ format!(
+ "array of {} entries; first entry keys: [{}]",
+ arr.len(),
+ first_keys
+ )
+ }
+ None => format!("non-array value of type {}", json_value_type_name(value)),
+ }
+}
+
+/// Cheap type-name string for a `serde_json::Value`. Used by
+/// `summarize_action_calls_for_log` to surface the wrong-shape case
+/// (e.g. Python passed a string instead of an array) without leaking the
+/// actual contents.
+fn json_value_type_name(value: &serde_json::Value) -> &'static str {
+ match value {
+ serde_json::Value::Null => "null",
+ serde_json::Value::Bool(_) => "bool",
+ serde_json::Value::Number(_) => "number",
+ serde_json::Value::String(_) => "string",
+ serde_json::Value::Array(_) => "array",
+ serde_json::Value::Object(_) => "object",
+ }
+}
+
+/// Deserialize an `action_calls` JSON array (in Python interchange shape)
+/// back into canonical `ActionCall`s.
+///
+/// Logs a warning on failure rather than swallowing silently. The whole
+/// commit that introduced this helper exists to undo a `.ok()` swallow that
+/// dropped action_calls without any signal — replacing it with another
+/// `.ok()?` would re-introduce the same trap, just one layer deeper. If the
+/// shape ever drifts again (Python orchestrator field rename, extra
+/// required field, partial migration), the warning is the operator-visible
+/// breadcrumb that explains why subsequent tool results suddenly look
+/// orphaned to `sanitize_tool_messages`.
+///
+/// The warn log emits a structural summary (`summarize_action_calls_for_log`)
+/// instead of the raw value because tool parameters can contain user PII.
+fn python_json_to_action_calls(value: &serde_json::Value) -> Option> {
+ match serde_json::from_value::>(value.clone()) {
+ Ok(parsed) => Some(parsed.into_iter().map(ActionCall::from).collect()),
+ Err(e) => {
+ warn!(
+ error = %e,
+ shape = %summarize_action_calls_for_log(value),
+ "Failed to parse action_calls from Python orchestrator — \
+ assistant message will lose tool_call linkage and downstream \
+ tool results will be rewritten as user messages"
+ );
+ None
+ }
+ }
+}
+
fn json_to_thread_messages(value: &serde_json::Value) -> Option> {
let arr = value.as_array()?;
let mut messages = Vec::with_capacity(arr.len());
@@ -1913,9 +2275,15 @@ fn json_to_thread_messages(value: &serde_json::Value) -> Option ThreadMessage::system(content),
@@ -2129,12 +2497,15 @@ mod tests {
other => panic!("FINAL() received non-bool: {other:?}"),
};
}
- // Unknown host function — return None and continue
+ // Dispatch the real host functions the test exercises so
+ // e.g. `__regex_match__` routes through the production
+ // handler instead of being stubbed out to `None`.
+ let ext_result = match call.function_name.as_str() {
+ "__regex_match__" => handle_regex_match(&call.args),
+ _ => ExtFunctionResult::Return(MontyObject::None),
+ };
progress = call
- .resume(
- ExtFunctionResult::Return(MontyObject::None),
- PrintWriter::Collect(&mut stdout),
- )
+ .resume(ext_result, PrintWriter::Collect(&mut stdout))
.expect("resume failed");
}
RunProgress::NameLookup(lookup) => {
@@ -2150,6 +2521,26 @@ mod tests {
}
}
+ // ── __regex_match__ host function reachability ───────────────
+
+ #[test]
+ fn regex_match_host_function_is_callable_from_monty() {
+ // Regression test for PR #1736 review (serrrfirat, 3059161877):
+ // verify that Monty's NameLookup + FunctionCall dispatch actually
+ // reaches `handle_regex_match` when default.py calls
+ // `__regex_match__(...)`. If Monty ever starts resolving the name
+ // before the call, this test will fail with a NameError.
+ assert!(eval_python_bool(
+ r#"bool(__regex_match__("abc", "xxabcxx"))"#
+ ));
+ assert!(!eval_python_bool(
+ r#"bool(__regex_match__("zzz", "xxabcxx"))"#
+ ));
+ // Invalid pattern should return false silently (the host function
+ // swallows the compile error).
+ assert!(!eval_python_bool(r#"bool(__regex_match__("[", "abc"))"#));
+ }
+
// ── True positives (should trigger nudge) ───────────────────
#[test]
@@ -2556,4 +2947,385 @@ mod tests {
let outcome = parse_outcome(&result);
assert!(matches!(outcome, ThreadOutcome::Stopped));
}
+
+ // ── Python ↔ Rust ActionCall round-trip ───────────────────────────────
+ //
+ // Regression tests for the orphaned-tool-result bug. The Python
+ // orchestrator stores `action_calls` on assistant messages using the
+ // shape `{name, call_id, params}`, but the canonical Rust `ActionCall`
+ // uses `{action_name, id, parameters}`. Without the explicit
+ // `PythonActionCall` interchange type, `serde_json::from_value` would
+ // silently fail (`.ok()` swallows the error) and the Python-shaped
+ // assistant message would be parsed back as a plain assistant message
+ // with no tool calls, causing every subsequent ActionResult to be
+ // detected as orphaned by `sanitize_tool_messages` in the host crate.
+
+ #[test]
+ fn python_action_call_round_trips_through_serde() {
+ let original = ActionCall {
+ id: "call_abc123".to_string(),
+ action_name: "google_drive_tool".to_string(),
+ parameters: serde_json::json!({"query": "expenses"}),
+ };
+
+ let python_json = serde_json::to_value(PythonActionCall::from(&original))
+ .expect("PythonActionCall must serialize");
+ // Python-friendly field names — match what default.py reads.
+ assert_eq!(python_json["name"], "google_drive_tool");
+ assert_eq!(python_json["call_id"], "call_abc123");
+ assert_eq!(
+ python_json["params"],
+ serde_json::json!({"query": "expenses"})
+ );
+
+ let parsed: PythonActionCall =
+ serde_json::from_value(python_json).expect("must deserialize");
+ let round_tripped: ActionCall = parsed.into();
+ assert_eq!(round_tripped.id, original.id);
+ assert_eq!(round_tripped.action_name, original.action_name);
+ assert_eq!(round_tripped.parameters, original.parameters);
+ }
+
+ #[test]
+ fn action_calls_to_python_json_uses_python_field_names() {
+ let calls = vec![
+ ActionCall {
+ id: "call_1".to_string(),
+ action_name: "notion_notion_search".to_string(),
+ parameters: serde_json::json!({"query": "name"}),
+ },
+ ActionCall {
+ id: "call_2".to_string(),
+ action_name: "google_drive_tool".to_string(),
+ parameters: serde_json::json!({"action": "list"}),
+ },
+ ];
+ let json = action_calls_to_python_json(&calls);
+ assert_eq!(json.len(), 2);
+ assert_eq!(json[0]["name"], "notion_notion_search");
+ assert_eq!(json[0]["call_id"], "call_1");
+ assert_eq!(json[1]["name"], "google_drive_tool");
+ assert_eq!(json[1]["call_id"], "call_2");
+ }
+
+ #[test]
+ fn python_json_to_action_calls_parses_python_field_names() {
+ // The exact shape default.py produces (and stores on assistant
+ // messages via `append_message(..., action_calls=calls)`).
+ let python_json = serde_json::json!([
+ {"name": "notion_notion_search", "call_id": "call_xyz", "params": {"q": "foo"}},
+ {"name": "google_drive_tool", "call_id": "call_abc", "params": {"action": "list"}},
+ ]);
+ let parsed = python_json_to_action_calls(&python_json).expect("must parse");
+ assert_eq!(parsed.len(), 2);
+ assert_eq!(parsed[0].action_name, "notion_notion_search");
+ assert_eq!(parsed[0].id, "call_xyz");
+ assert_eq!(parsed[0].parameters, serde_json::json!({"q": "foo"}));
+ assert_eq!(parsed[1].action_name, "google_drive_tool");
+ assert_eq!(parsed[1].id, "call_abc");
+ }
+
+ #[test]
+ fn python_json_to_action_calls_rejects_canonical_field_names() {
+ // Sanity check: the parser is strict about Python field names.
+ // If `default.py` ever changes the shape, the test must catch it.
+ let canonical_json = serde_json::json!([
+ {"action_name": "search", "id": "call_x", "parameters": {}}
+ ]);
+ // Missing "name", "call_id", "params" → returns None.
+ assert!(python_json_to_action_calls(&canonical_json).is_none());
+ }
+
+ #[test]
+ fn summarize_action_calls_for_log_does_not_leak_user_pii() {
+ // The whole point of this helper is that the warn log path on a
+ // shape-drift failure must NOT dump tool parameters (which can
+ // contain user PII like search queries, file names, email content)
+ // into log aggregation systems. The summary should expose only
+ // structural information: array length and the keys of the first
+ // entry. The keys themselves are static (`name`, `call_id`,
+ // `params`), not user data.
+ let pii_value = serde_json::json!([
+ {
+ "name": "google_drive_tool",
+ "call_id": "call_xyz",
+ "params": {
+ "query": "salary spreadsheet for joe",
+ "secret_token": "very-sensitive-token-do-not-log"
+ }
+ },
+ {
+ "name": "gmail",
+ "call_id": "call_abc",
+ "params": {
+ "subject": "private message about layoffs"
+ }
+ }
+ ]);
+ let summary = summarize_action_calls_for_log(&pii_value);
+
+ // Structural info present.
+ assert!(summary.contains("array of 2 entries"));
+ assert!(summary.contains("call_id"));
+ assert!(summary.contains("name"));
+ assert!(summary.contains("params"));
+
+ // PII fields and their values must NOT appear.
+ assert!(
+ !summary.contains("salary"),
+ "summary must not leak user PII from params: {summary}"
+ );
+ assert!(
+ !summary.contains("very-sensitive-token"),
+ "summary must not leak credential-shaped values: {summary}"
+ );
+ assert!(
+ !summary.contains("layoffs"),
+ "summary must not leak free-text content: {summary}"
+ );
+ assert!(
+ !summary.contains("google_drive_tool"),
+ "summary must not leak the tool name itself (could expose intent): {summary}"
+ );
+ }
+
+ #[test]
+ fn summarize_action_calls_for_log_handles_edge_cases() {
+ assert_eq!(
+ summarize_action_calls_for_log(&serde_json::json!([])),
+ "empty array"
+ );
+ assert!(
+ summarize_action_calls_for_log(&serde_json::json!("not an array")).contains("string")
+ );
+ assert!(
+ summarize_action_calls_for_log(&serde_json::json!({"foo": "bar"})).contains("object")
+ );
+ assert!(summarize_action_calls_for_log(&serde_json::json!(null)).contains("null"));
+ }
+
+ /// Caller-level regression test: feeds `json_to_thread_messages` the
+ /// exact JSON shape that `default.py` produces for an assistant message
+ /// with tool calls followed by tool results, and asserts that the
+ /// resulting `ThreadMessage`s preserve the `action_calls` ↔
+ /// `action_call_id` linkage. Without the `PythonActionCall` parser the
+ /// assistant message would come back with `action_calls = None` and
+ /// every following ActionResult would look orphaned to the bridge.
+ #[test]
+ fn json_to_thread_messages_preserves_action_calls_from_python_orchestrator() {
+ // This is the literal shape `default.py` writes into
+ // `state["working_messages"]` after a Tier 0 step:
+ //
+ // append_message(working_messages, "Assistant", "...", action_calls=calls)
+ // append_message(working_messages, "ActionResult", "...", action_name=..., action_call_id=...)
+ //
+ // where `calls` came from the LLM response and has shape
+ // `[{"name": ..., "call_id": ..., "params": ...}]`.
+ let working_messages = serde_json::json!([
+ {"role": "User", "content": "search in notion for my name"},
+ {
+ "role": "Assistant",
+ "content": "",
+ "action_calls": [
+ {
+ "name": "notion_notion_search",
+ "call_id": "call_xyz",
+ "params": {"query": "Illia"}
+ }
+ ]
+ },
+ {
+ "role": "ActionResult",
+ "content": "found 3 results",
+ "action_name": "notion_notion_search",
+ "action_call_id": "call_xyz"
+ }
+ ]);
+
+ let messages = json_to_thread_messages(&working_messages).expect("must parse");
+ assert_eq!(messages.len(), 3);
+
+ // The assistant message MUST have action_calls populated, with
+ // matching call_id. If this assertion fails, the bridge layer
+ // will treat the following ActionResult as orphaned and rewrite
+ // it as a user message — losing the model's ability to reason
+ // about prior tool output.
+ let assistant = &messages[1];
+ assert_eq!(
+ assistant.role,
+ crate::types::message::MessageRole::Assistant
+ );
+ let calls = assistant
+ .action_calls
+ .as_ref()
+ .expect("assistant message must carry action_calls after round-trip");
+ assert_eq!(calls.len(), 1);
+ assert_eq!(calls[0].id, "call_xyz");
+ assert_eq!(calls[0].action_name, "notion_notion_search");
+ assert_eq!(calls[0].parameters, serde_json::json!({"query": "Illia"}));
+
+ // The ActionResult must reference the same call_id so the bridge
+ // can pair them.
+ let result = &messages[2];
+ assert_eq!(
+ result.role,
+ crate::types::message::MessageRole::ActionResult
+ );
+ assert_eq!(result.action_call_id.as_deref(), Some("call_xyz"));
+ assert_eq!(result.action_name.as_deref(), Some("notion_notion_search"));
+ }
+
+ /// Regression for the gate-resume / bootstrap path: when a thread
+ /// resumes after approval or auth, `build_orchestrator_inputs`
+ /// serializes `thread.internal_messages` into the bootstrap context
+ /// that Python reads into `working_messages`. If `action_calls` is
+ /// serialized with canonical `ActionCall` field names (`action_name`,
+ /// `id`, `parameters`) instead of the Python interchange names
+ /// (`name`, `call_id`, `params`), the next `__llm_complete__` call
+ /// passes them back through `json_to_thread_messages` which fails
+ /// with "missing field `name`" and orphans every subsequent tool
+ /// result.
+ ///
+ /// This test simulates the full round-trip: build a `ThreadMessage`
+ /// with action_calls → serialize through `build_orchestrator_inputs`'s
+ /// exact serialization pattern → parse back through
+ /// `json_to_thread_messages` → assert the calls survive. If anyone
+ /// adds a THIRD serialization path in the future and uses canonical
+ /// names, this test documents the pattern they should follow.
+ #[test]
+ fn bootstrap_context_action_calls_round_trip_through_python_interchange() {
+ // Build a thread message the way the engine does: an assistant
+ // message with action_calls in canonical ActionCall format (the
+ // shape stored in the DB / internal_messages).
+ let msg = ThreadMessage::assistant_with_actions(
+ Some("I'll search for that".to_string()),
+ vec![ActionCall {
+ id: "call_resume_test".to_string(),
+ action_name: "google_drive_tool".to_string(),
+ parameters: serde_json::json!({"query": "budget"}),
+ }],
+ );
+
+ // Serialize through the SAME pattern `build_orchestrator_inputs`
+ // uses. This is the exact code path that was broken before the
+ // fix — it was using `"action_calls": m.action_calls` which
+ // produced canonical field names.
+ let calls_json = msg
+ .action_calls
+ .as_ref()
+ .map(|calls| serde_json::Value::Array(action_calls_to_python_json(calls)));
+ let serialized = serde_json::json!([{
+ "role": "Assistant",
+ "content": msg.content,
+ "action_name": msg.action_name,
+ "action_call_id": msg.action_call_id,
+ "action_calls": calls_json,
+ }]);
+
+ // Parse back through the same path Python's working_messages
+ // takes when it calls __llm_complete__.
+ let parsed = json_to_thread_messages(&serialized).expect("must parse");
+ assert_eq!(parsed.len(), 1);
+
+ let assistant = &parsed[0];
+ let calls = assistant.action_calls.as_ref().expect(
+ "bootstrap context action_calls must survive the round-trip. \
+ If this fails, a serialization path is using canonical ActionCall \
+ field names instead of PythonActionCall interchange names.",
+ );
+ assert_eq!(calls.len(), 1);
+ assert_eq!(calls[0].id, "call_resume_test");
+ assert_eq!(calls[0].action_name, "google_drive_tool");
+ assert_eq!(calls[0].parameters, serde_json::json!({"query": "budget"}));
+ }
+
+ /// Negative regression: verify that canonical ActionCall field names
+ /// do NOT round-trip. If this test ever PASSES, it means someone
+ /// added `#[serde(rename)]` to ActionCall or changed the parser to
+ /// accept both formats — which is fine, but the PythonActionCall
+ /// interchange type can then be removed. This test documents the
+ /// current contract: canonical names are rejected by the parser.
+ #[test]
+ fn canonical_action_call_field_names_do_not_round_trip() {
+ let serialized_with_canonical_names = serde_json::json!([{
+ "role": "Assistant",
+ "content": "",
+ "action_calls": [{
+ "action_name": "search",
+ "id": "call_x",
+ "parameters": {}
+ }],
+ }]);
+ let parsed =
+ json_to_thread_messages(&serialized_with_canonical_names).expect("messages parse");
+ // The assistant message should have NO action_calls because the
+ // parser rejects canonical field names.
+ assert!(
+ parsed[0].action_calls.is_none(),
+ "canonical ActionCall field names must NOT parse as action_calls. \
+ If this assertion fails, the PythonActionCall interchange type \
+ is no longer needed — either remove it or update the contract."
+ );
+ }
+
+ /// Regression: `action_calls: null` is Python's legitimate "this
+ /// message has no tool calls" signal (text-only response). Before the
+ /// null filter, `python_json_to_action_calls` would fire a warn log
+ /// with "invalid type: null, expected a sequence" on every text-only
+ /// assistant message — a false alarm that masked real drift issues.
+ #[test]
+ fn json_to_thread_messages_handles_null_action_calls_gracefully() {
+ let messages = serde_json::json!([
+ {
+ "role": "Assistant",
+ "content": "Here is your answer.",
+ "action_calls": null
+ }
+ ]);
+ let parsed = json_to_thread_messages(&messages).expect("must parse");
+ assert_eq!(parsed.len(), 1);
+ assert_eq!(
+ parsed[0].role,
+ crate::types::message::MessageRole::Assistant
+ );
+ assert_eq!(parsed[0].content, "Here is your answer.");
+ assert!(
+ parsed[0].action_calls.is_none(),
+ "null action_calls must produce None, not a parse error"
+ );
+ }
+
+ /// Verify that messages WITHOUT the action_calls key at all (the most
+ /// common case for text responses) also parse correctly — this is the
+ /// baseline that the null-filtering regression test extends.
+ #[test]
+ fn json_to_thread_messages_handles_absent_action_calls() {
+ let messages = serde_json::json!([
+ {"role": "Assistant", "content": "Just text, no tools."}
+ ]);
+ let parsed = json_to_thread_messages(&messages).expect("must parse");
+ assert_eq!(parsed.len(), 1);
+ assert!(parsed[0].action_calls.is_none());
+ }
+
+ /// Empty action_calls array is valid (LLM decided not to call any
+ /// tools this turn but the response still has the array field). Must
+ /// produce `Some(vec![])`, not `None`.
+ #[test]
+ fn json_to_thread_messages_handles_empty_action_calls_array() {
+ let messages = serde_json::json!([
+ {
+ "role": "Assistant",
+ "content": "No tools needed.",
+ "action_calls": []
+ }
+ ]);
+ let parsed = json_to_thread_messages(&messages).expect("must parse");
+ assert_eq!(parsed.len(), 1);
+ let calls = parsed[0]
+ .action_calls
+ .as_ref()
+ .expect("empty array should produce Some(vec![])");
+ assert!(calls.is_empty());
+ }
}
diff --git a/crates/ironclaw_engine/src/executor/scripting.rs b/crates/ironclaw_engine/src/executor/scripting.rs
index e4e5065b561..eb6e7bcf571 100644
--- a/crates/ironclaw_engine/src/executor/scripting.rs
+++ b/crates/ironclaw_engine/src/executor/scripting.rs
@@ -35,6 +35,7 @@ use crate::types::event::EventKind;
use crate::types::message::{MessageRole, ThreadMessage};
use crate::types::step::{ActionResult, LlmResponse, TokenUsage};
use crate::types::thread::Thread;
+use ironclaw_common::ValidTimezone;
// ── Configuration ───────────────────────────────────────────
@@ -226,6 +227,17 @@ fn build_context_inputs(
names.push("previous_results".into());
values.push(MontyObject::dict(result_pairs));
+ // `user_timezone` — validated IANA timezone from the user's channel (e.g. "America/New_York")
+ let tz = thread
+ .metadata
+ .get("user_timezone")
+ .and_then(|v| v.as_str())
+ .and_then(ValidTimezone::parse)
+ .map(|vtz| vtz.name().to_string())
+ .unwrap_or_else(|| "UTC".into());
+ names.push("user_timezone".into());
+ values.push(MontyObject::String(tz));
+
(names, values)
}
@@ -1268,13 +1280,35 @@ async fn resolve_tool_future(
) -> ExtFunctionResult {
match handle.await {
Ok(Ok(result)) => {
- events.push(EventKind::ActionExecuted {
- step_id: context.step_id,
- action_name: action_name.into(),
- call_id: call_id.into(),
- duration_ms: result.duration.as_millis() as u64,
- params_summary,
- });
+ // If the effect adapter wrapped a tool error as an Ok(ActionResult)
+ // with is_error=true (current convention in
+ // `EffectBridgeAdapter::execute_action_internal`), surface it as
+ // ActionFailed so traces, observers, and approval flows see the
+ // failure correctly. Without this, every wrapped error looked like
+ // a successful tool call to downstream consumers.
+ if result.is_error {
+ let error_msg = result
+ .output
+ .get("error")
+ .and_then(|v| v.as_str())
+ .map(String::from)
+ .unwrap_or_else(|| result.output.to_string());
+ events.push(EventKind::ActionFailed {
+ step_id: context.step_id,
+ action_name: action_name.into(),
+ call_id: call_id.into(),
+ error: error_msg,
+ params_summary,
+ });
+ } else {
+ events.push(EventKind::ActionExecuted {
+ step_id: context.step_id,
+ action_name: action_name.into(),
+ call_id: call_id.into(),
+ duration_ms: result.duration.as_millis() as u64,
+ params_summary,
+ });
+ }
let monty_val = json_to_monty(&result.output);
action_results.push(result);
ExtFunctionResult::Return(monty_val)
@@ -1567,6 +1601,7 @@ mod tests {
step_id: StepId::new(),
current_call_id: None,
source_channel: None,
+ user_timezone: None,
}
}
diff --git a/crates/ironclaw_engine/src/executor/structured.rs b/crates/ironclaw_engine/src/executor/structured.rs
index b249b581d24..6d197b52b4d 100644
--- a/crates/ironclaw_engine/src/executor/structured.rs
+++ b/crates/ironclaw_engine/src/executor/structured.rs
@@ -323,12 +323,31 @@ fn classify_exec_result(
match result {
Ok(mut action_result) => {
action_result.call_id = call.id.clone();
- let event = EventKind::ActionExecuted {
- step_id: context.step_id,
- action_name: call.action_name.clone(),
- call_id: call.id.clone(),
- duration_ms: action_result.duration.as_millis() as u64,
- params_summary: None,
+ // Effect adapters wrap tool errors as `Ok(ActionResult { is_error: true })`
+ // — emit ActionFailed in that case so traces and downstream
+ // observers see the failure rather than treating it as success.
+ let event = if action_result.is_error {
+ let error_msg = action_result
+ .output
+ .get("error")
+ .and_then(|v| v.as_str())
+ .map(String::from)
+ .unwrap_or_else(|| action_result.output.to_string());
+ EventKind::ActionFailed {
+ step_id: context.step_id,
+ action_name: call.action_name.clone(),
+ call_id: call.id.clone(),
+ error: error_msg,
+ params_summary: None,
+ }
+ } else {
+ EventKind::ActionExecuted {
+ step_id: context.step_id,
+ action_name: call.action_name.clone(),
+ call_id: call.id.clone(),
+ duration_ms: action_result.duration.as_millis() as u64,
+ params_summary: None,
+ }
};
(action_result, event)
}
@@ -470,6 +489,7 @@ mod tests {
step_id: StepId::new(),
current_call_id: None,
source_channel: None,
+ user_timezone: None,
}
}
diff --git a/crates/ironclaw_engine/src/executor/trace.rs b/crates/ironclaw_engine/src/executor/trace.rs
index 4a908f13203..0252c30c3df 100644
--- a/crates/ironclaw_engine/src/executor/trace.rs
+++ b/crates/ironclaw_engine/src/executor/trace.rs
@@ -555,11 +555,14 @@ mod tests {
));
let trace = build_trace(&thread);
+ // `Thread::add_message` records a `MessageAdded` event for each
+ // message, so the `ApprovalRequested` event is no longer at index 0
+ // — it's mixed in with the message events. Find it by kind.
let approval = trace
.events
.iter()
.find(|e| matches!(&e.kind, EventKind::ApprovalRequested { .. }))
- .expect("should have ApprovalRequested event");
+ .expect("trace should contain an ApprovalRequested event");
match &approval.kind {
EventKind::ApprovalRequested {
action_name,
@@ -588,6 +591,8 @@ mod tests {
assert!(json.contains("\"ApprovalRequested\""));
assert!(json.contains("\"action_name\":\"tool_install\""));
assert!(json.contains("\"call_id\":\"call_install_1\""));
+ // Parameter map key order isn't stable across serde_json versions; check
+ // both required keys are present rather than the exact serialized form.
assert!(json.contains("\"name\":\"notion\""));
assert!(json.contains("\"kind\":\"mcp_server\""));
assert!(json.contains("\"description\":\"Install an extension\""));
diff --git a/crates/ironclaw_engine/src/lib.rs b/crates/ironclaw_engine/src/lib.rs
index d3b5c86b708..5894d7a7a64 100644
--- a/crates/ironclaw_engine/src/lib.rs
+++ b/crates/ironclaw_engine/src/lib.rs
@@ -14,6 +14,15 @@
//! [`Store`], [`EffectExecutor`]) that the host crate implements via bridge
//! adapters over existing infrastructure.
+// Security: `__regex_match__` (in `executor/orchestrator.rs`) accepts
+// arbitrary patterns from the Python orchestrator and runs them on
+// user-supplied text. The default `regex` crate is linear-time. The
+// `fancy-regex` crate supports backreferences and is NOT linear-time, which
+// would turn that handler into a ReDoS vector. Cargo.toml depends on
+// `regex = "1"` with default features only — do NOT add `fancy-regex` to
+// this crate's dependency tree without first redesigning `__regex_match__`
+// to enforce a wall-clock matching budget.
+
pub mod capability;
pub mod executor;
pub mod gate;
@@ -33,7 +42,7 @@ pub use types::error::{CapabilityError, EngineError, StepError, ThreadError};
pub use types::event::{EventId, EventKind, ThreadEvent};
pub use types::memory::{DocId, DocType, MemoryDoc};
pub use types::message::{MessageRole, ThreadMessage};
-pub use types::mission::{Mission, MissionCadence, MissionId, MissionStatus};
+pub use types::mission::{Mission, MissionCadence, MissionId, MissionStatus, ValidTimezone};
pub use types::project::{Project, ProjectId};
pub use types::provenance::Provenance;
pub use types::step::{
diff --git a/crates/ironclaw_engine/src/memory/skill_tracker.rs b/crates/ironclaw_engine/src/memory/skill_tracker.rs
index 0b21c29074b..c3d7f57e3e8 100644
--- a/crates/ironclaw_engine/src/memory/skill_tracker.rs
+++ b/crates/ironclaw_engine/src/memory/skill_tracker.rs
@@ -39,8 +39,9 @@ impl SkillTracker {
/// Record that a skill was used in a completed thread.
///
/// Loads the skill's MemoryDoc, updates metrics in the metadata JSON,
- /// and saves it back. If the doc is not found or has invalid metadata,
- /// the error is logged and the operation is skipped.
+ /// and saves it back. Returns `Err(EngineError::Skill)` if the doc is
+ /// missing, not a Skill, or has invalid metadata — callers decide whether
+ /// to propagate or log-and-swallow.
pub async fn record_usage(&self, doc_id: DocId, success: bool) -> Result<(), EngineError> {
let doc = self
.store
diff --git a/crates/ironclaw_engine/src/runtime/conversation.rs b/crates/ironclaw_engine/src/runtime/conversation.rs
index 8330bd29dab..0c4b1291342 100644
--- a/crates/ironclaw_engine/src/runtime/conversation.rs
+++ b/crates/ironclaw_engine/src/runtime/conversation.rs
@@ -196,6 +196,7 @@ impl ConversationManager {
project_id: ProjectId,
user_id: &str,
thread_config: ThreadConfig,
+ user_timezone: Option<&str>,
) -> Result {
let conv_arc = self.get_conversation_lock(conversation_id).await?;
let mut conv = conv_arc.lock().await;
@@ -225,6 +226,12 @@ impl ConversationManager {
thread_id = %thread_id,
"injecting message into active thread"
);
+ // Known limitation: a tz change mid-turn (user travels between
+ // messages of the same active thread) is not propagated. The
+ // running ExecutionLoop holds an in-memory copy of the Thread
+ // and cannot be updated externally without a new signal type.
+ // Updating the persisted record here would not affect the live
+ // step. Rare in practice; defer to a follow-up if needed.
self.thread_manager
.inject_message(thread_id, user_id, ThreadMessage::user(content))
.await?;
@@ -236,6 +243,24 @@ impl ConversationManager {
thread_id = %thread_id,
"resuming suspended foreground thread"
);
+ // Resume reloads the thread from the store, so writing fresh
+ // user_timezone to the persisted record before resume_thread
+ // means the resumed execution sees the up-to-date value — but
+ // only if this write actually lands. A store failure here
+ // would silently leave the resumed thread with the prior
+ // timezone, so log explicitly rather than swallowing.
+ if let Some(tz) = user_timezone
+ && let Err(e) = self
+ .thread_manager
+ .set_thread_metadata(thread_id, "user_timezone", tz)
+ .await
+ {
+ debug!(
+ thread_id = %thread_id,
+ error = %e,
+ "failed to refresh user_timezone on resume; thread will use previous value"
+ );
+ }
self.thread_manager
.resume_thread(
thread_id,
@@ -253,19 +278,31 @@ impl ConversationManager {
// so deferring avoids an O(entries) allocation on those fast paths.
let history = build_history_from_entries(&conv.entries);
- // Compute the base channel name (strip any thread-scoped suffix)
- // and pass it into spawn so it lands in `thread.metadata.source_channel`
- // BEFORE the execution task takes ownership of the Thread struct.
- // The orchestrator reads this on the very first step to populate
- // `ThreadExecutionContext.source_channel`, which `mission_create`
- // consults to default `notify_channels`. Setting metadata after
- // spawn would only update the persisted copy — not the in-memory
- // Thread the running task already owns.
+ // Build initial thread metadata. Must be applied *before* the
+ // executor's background task starts — `set_thread_metadata`
+ // only updates the persisted record, not the in-memory Thread
+ // the loop is reading from, so the first step would otherwise
+ // miss `user_timezone` / `source_channel`. The bridge router
+ // validates the timezone string before passing it in here.
+ // The orchestrator reads `source_channel` on the very first
+ // step to populate `ThreadExecutionContext.source_channel`,
+ // which `mission_create` consults to default `notify_channels`.
let base_channel = channel_name
.split(':')
.next()
.unwrap_or(&channel_name)
.to_string();
+ let mut initial_metadata = serde_json::Map::new();
+ initial_metadata.insert(
+ "source_channel".into(),
+ serde_json::Value::String(base_channel),
+ );
+ if let Some(tz) = user_timezone {
+ initial_metadata.insert(
+ "user_timezone".into(),
+ serde_json::Value::String(tz.to_string()),
+ );
+ }
// Spawn new foreground thread with conversation history.
self.thread_manager
@@ -277,7 +314,7 @@ impl ConversationManager {
None,
user_id,
history,
- Some(base_channel),
+ initial_metadata,
)
.await?
}
@@ -800,7 +837,14 @@ mod tests {
let project = ProjectId::new();
let tid = cm
- .handle_user_message(conv_id, "Hello", project, "user1", ThreadConfig::default())
+ .handle_user_message(
+ conv_id,
+ "Hello",
+ project,
+ "user1",
+ ThreadConfig::default(),
+ None,
+ )
.await
.unwrap();
@@ -867,6 +911,7 @@ mod tests {
project,
"user1",
ThreadConfig::default(),
+ None,
)
.await
.unwrap();
@@ -959,7 +1004,14 @@ mod tests {
// Spawn a thread so the conversation has entries and active threads
let tid = cm
- .handle_user_message(conv_id, "Hello", project, "user1", ThreadConfig::default())
+ .handle_user_message(
+ conv_id,
+ "Hello",
+ project,
+ "user1",
+ ThreadConfig::default(),
+ None,
+ )
.await
.unwrap();
@@ -1007,6 +1059,7 @@ mod tests {
project,
"user1",
ThreadConfig::default(),
+ None,
)
.await
});
@@ -1017,6 +1070,7 @@ mod tests {
project,
"user1",
ThreadConfig::default(),
+ None,
)
.await
});
@@ -1092,6 +1146,7 @@ mod tests {
project,
"user1",
ThreadConfig::default(),
+ None,
)
.await
.unwrap();
diff --git a/crates/ironclaw_engine/src/runtime/manager.rs b/crates/ironclaw_engine/src/runtime/manager.rs
index 8d1e8e8f3e4..5fb7eb4cdb9 100644
--- a/crates/ironclaw_engine/src/runtime/manager.rs
+++ b/crates/ironclaw_engine/src/runtime/manager.rs
@@ -102,20 +102,22 @@ impl ThreadManager {
parent_id,
user_id,
Vec::new(),
- None,
+ serde_json::Map::new(),
)
.await
}
/// Spawn a thread with initial conversation history.
///
- /// `source_channel` records the channel name (e.g. "gateway") that
- /// originated this thread. It is stored in `thread.metadata.source_channel`
- /// **before** the execution task is spawned, so the orchestrator's
- /// `ThreadExecutionContext` sees it on the very first step. Setting it
- /// post-spawn via `set_thread_metadata` is a race — the spawned task owns
- /// its own in-memory copy of the `Thread`, and the late metadata update
- /// only lands on the persisted copy that the running task never re-reads.
+ /// `initial_metadata` is applied to the thread's metadata map *before* the
+ /// background execution task starts, so the executor's in-memory `Thread`
+ /// observes those keys on the first step. This is the only correct way to
+ /// stamp metadata that the very first orchestrator step needs to read
+ /// (e.g. `source_channel` for `mission_create` notify-channel defaulting,
+ /// or `user_timezone` for cron resolution). Setting metadata after spawn
+ /// via `set_thread_metadata` is a race — the spawned task owns its own
+ /// in-memory copy of the `Thread`, and the late update only lands on the
+ /// persisted copy that the running task never re-reads.
#[allow(clippy::too_many_arguments)]
pub async fn spawn_thread_with_history(
&self,
@@ -126,27 +128,24 @@ impl ThreadManager {
parent_id: Option,
user_id: impl Into,
initial_messages: Vec,
- source_channel: Option,
+ initial_metadata: serde_json::Map,
) -> Result {
let user_id = user_id.into();
let mut thread = Thread::new(goal, thread_type, project_id, &user_id, config);
if let Some(pid) = parent_id {
thread = thread.with_parent(pid);
}
- // Stamp source_channel into metadata BEFORE the execution task takes
- // ownership of the Thread struct. The orchestrator reads this via
- // `thread_source_channel(thread)` and uses it to populate
- // `ThreadExecutionContext.source_channel`, which downstream tools
- // (notably `mission_create`) consult to default `notify_channels`.
- if let Some(channel) = source_channel
+ let thread_id = thread.id;
+
+ // Apply initial metadata before save_thread + start_thread so the
+ // executor's in-memory thread observes it on the first step.
+ if !initial_metadata.is_empty()
&& let Some(obj) = thread.metadata.as_object_mut()
{
- obj.insert(
- "source_channel".to_string(),
- serde_json::Value::String(channel),
- );
+ for (k, v) in initial_metadata {
+ obj.insert(k, v);
+ }
}
- let thread_id = thread.id;
// Register in tree
if let Some(pid) = parent_id {
@@ -454,17 +453,40 @@ impl ThreadManager {
}
}
- /// Set a metadata key on a thread (best-effort, for tagging).
- pub async fn set_thread_metadata(&self, thread_id: ThreadId, key: &str, value: &str) {
- if let Ok(Some(mut thread)) = self.store.load_thread(thread_id).await {
- if let Some(obj) = thread.metadata.as_object_mut() {
- obj.insert(
- key.to_string(),
- serde_json::Value::String(value.to_string()),
- );
- }
- let _ = self.store.save_thread(&thread).await;
+ /// Set a metadata key on the persisted thread record.
+ ///
+ /// Note: this updates the **store**, not the in-memory `Thread` that an
+ /// already-running `ExecutionLoop` is reading from. Callers that need the
+ /// next executor step to observe the new value must apply this *before*
+ /// the executor task is spawned (initial-create path) or before
+ /// `resume_thread`, which reloads from the store.
+ pub async fn set_thread_metadata(
+ &self,
+ thread_id: ThreadId,
+ key: &str,
+ value: &str,
+ ) -> Result<(), EngineError> {
+ let mut thread = self
+ .store
+ .load_thread(thread_id)
+ .await
+ .map_err(|e| EngineError::Store {
+ reason: format!("set_thread_metadata: load failed: {e}"),
+ })?
+ .ok_or(EngineError::ThreadNotFound(thread_id))?;
+ if let Some(obj) = thread.metadata.as_object_mut() {
+ obj.insert(
+ key.to_string(),
+ serde_json::Value::String(value.to_string()),
+ );
}
+ self.store
+ .save_thread(&thread)
+ .await
+ .map_err(|e| EngineError::Store {
+ reason: format!("set_thread_metadata: save failed: {e}"),
+ })?;
+ Ok(())
}
/// Check if a thread is still running.
diff --git a/crates/ironclaw_engine/src/runtime/mission.rs b/crates/ironclaw_engine/src/runtime/mission.rs
index 90119bfdc1a..c7c95ae8928 100644
--- a/crates/ironclaw_engine/src/runtime/mission.rs
+++ b/crates/ironclaw_engine/src/runtime/mission.rs
@@ -6,6 +6,7 @@
use std::collections::{HashMap, HashSet, VecDeque};
use std::sync::Arc;
+use std::time::Duration;
use serde::Deserialize;
use tokio::sync::RwLock;
@@ -22,7 +23,9 @@ use crate::traits::store::Store;
use crate::traits::workspace::WorkspaceReader;
use crate::types::error::EngineError;
use crate::types::memory::{DocId, DocType, MemoryDoc};
-use crate::types::mission::{Mission, MissionCadence, MissionId, MissionStatus};
+use crate::types::mission::{
+ Mission, MissionCadence, MissionId, MissionStatus, next_cron_fire, next_cron_fire_required,
+};
use crate::types::project::ProjectId;
use crate::types::shared_owner_id;
use crate::types::thread::{
@@ -128,6 +131,17 @@ pub struct MissionManager {
active: RwLock>,
/// Broadcast channel for mission outcome notifications.
notification_tx: tokio::sync::broadcast::Sender,
+ /// Per-mission in-memory cooldown timestamp, recorded after each
+ /// `fire_mission` attempt regardless of whether `save_mission` succeeded.
+ ///
+ /// `tick` consults this to suppress re-firing the same mission within
+ /// [`FIRE_COOLDOWN`] when a transient store failure has prevented
+ /// `next_fire_at` / `threads_today` from advancing in the persisted record.
+ /// Without this guard, a save failure after a successful fire would cause
+ /// the next 60 s tick (and every subsequent tick) to re-fire the same
+ /// mission until the store recovers, spawning duplicate threads up to the
+ /// daily budget.
+ last_fire_attempt: RwLock>>,
/// Optional workspace reader used to load `Mission.context_paths` at
/// fire time. When `None`, context preloading is silently skipped.
workspace: Option>,
@@ -146,6 +160,12 @@ pub struct MissionManager {
budget_gate: Option>,
}
+/// Minimum gap between successive `fire_mission` attempts for the same
+/// mission ID, enforced in-memory by `tick`. Chosen to comfortably exceed the
+/// 60 s tick interval so a single tick gap is always honored, while still
+/// allowing recovery within a few minutes if the store comes back.
+const FIRE_COOLDOWN: Duration = Duration::from_secs(90);
+
impl MissionManager {
pub fn new(store: Arc, thread_manager: Arc) -> Self {
let (notification_tx, _) = tokio::sync::broadcast::channel(64);
@@ -154,6 +174,7 @@ impl MissionManager {
thread_manager,
active: RwLock::new(Vec::new()),
notification_tx,
+ last_fire_attempt: RwLock::new(HashMap::new()),
workspace: None,
dedup_table: RwLock::new(HashMap::new()),
event_regex_cache: RwLock::new(HashMap::new()),
@@ -202,14 +223,94 @@ impl MissionManager {
}
/// Populate the active mission index from persisted mission state.
+ ///
+ /// Also backfills `next_fire_at` for active cron missions created before
+ /// the scheduling fix — without this, legacy cron missions would remain
+ /// stuck with `next_fire_at = None` and never fire.
pub async fn bootstrap_project(&self, project_id: ProjectId) -> Result {
// System operation: load all missions for the project regardless of user.
let missions = self.store.list_all_missions(project_id).await?;
- let active_ids: Vec = missions
- .into_iter()
- .filter(|mission| mission.status == MissionStatus::Active)
- .map(|mission| mission.id)
- .collect();
+ let mut active_ids = Vec::new();
+
+ for mission in missions {
+ if mission.status != MissionStatus::Active {
+ continue;
+ }
+ // Backfill next_fire_at for cron missions that predate the
+ // scheduling fix. Match all three branches of next_cron_fire so a
+ // mission with an unschedulable cron (Ok(None) — e.g. a year-locked
+ // expression in the past) or an invalid expression (Err) is at
+ // least observable in the logs instead of silently staying stuck.
+ //
+ // Lenient `next_cron_fire` (not `_required`): startup backfill must
+ // never block — a single corrupt persisted expression cannot fail
+ // bootstrap, since the rest of the active missions still need to
+ // register. See `next_cron_fire_required` for the strict variant
+ // used at lifecycle entry points.
+ if let MissionCadence::Cron {
+ ref expression,
+ ref timezone,
+ } = mission.cadence
+ && mission.next_fire_at.is_none()
+ {
+ match next_cron_fire(expression, timezone.as_ref()) {
+ Ok(Some(next)) => {
+ // Re-load the mission immediately before save to narrow
+ // the TOCTOU window between the initial list_all_missions
+ // snapshot and our save. If a concurrent fire/update has
+ // already populated next_fire_at, skip — that writer's
+ // copy is fresher than ours. The remaining race window
+ // (between this re-load and save_mission) is much smaller
+ // than the original list-then-save window, and a strict
+ // CAS would require a new Store trait method.
+ match self.store.load_mission(mission.id).await {
+ Ok(Some(mut fresh)) if fresh.next_fire_at.is_none() => {
+ fresh.next_fire_at = Some(next);
+ match self.store.save_mission(&fresh).await {
+ Ok(()) => debug!(
+ mission_id = %mission.id,
+ next = %next,
+ "backfilled next_fire_at for legacy cron mission"
+ ),
+ Err(e) => debug!(
+ mission_id = %mission.id,
+ error = %e,
+ "failed to persist next_fire_at backfill; mission will retry on next bootstrap"
+ ),
+ }
+ }
+ Ok(Some(_)) => debug!(
+ mission_id = %mission.id,
+ "next_fire_at already set by concurrent writer; skipping backfill"
+ ),
+ Ok(None) => debug!(
+ mission_id = %mission.id,
+ "mission deleted between bootstrap list and backfill; skipping"
+ ),
+ Err(e) => debug!(
+ mission_id = %mission.id,
+ error = %e,
+ "failed to re-load mission for backfill"
+ ),
+ }
+ }
+ Ok(None) => debug!(
+ mission_id = %mission.id,
+ expression = %expression,
+ timezone = ?timezone,
+ "legacy cron mission has no upcoming fire time; leaving next_fire_at unset"
+ ),
+ Err(e) => debug!(
+ mission_id = %mission.id,
+ expression = %expression,
+ timezone = ?timezone,
+ error = %e,
+ "failed to compute next_fire_at for legacy cron mission; leaving next_fire_at unset"
+ ),
+ }
+ }
+ active_ids.push(mission.id);
+ }
let count = active_ids.len();
*self.active.write().await = active_ids;
@@ -228,6 +329,15 @@ impl MissionManager {
notify_channels: Vec,
) -> Result {
let mut mission = Mission::new(project_id, user_id, name, goal, cadence);
+ if let MissionCadence::Cron {
+ ref expression,
+ ref timezone,
+ } = mission.cadence
+ {
+ // Reject Ok(None) at the create boundary — an Active cron mission
+ // with `next_fire_at = None` is the original #1944 failure mode.
+ mission.next_fire_at = Some(next_cron_fire_required(expression, timezone.as_ref())?);
+ }
mission.notify_channels = notify_channels;
let id = mission.id;
self.store.save_mission(&mission).await?;
@@ -274,6 +384,29 @@ impl MissionManager {
}
if let Some(cadence) = updates.cadence {
mission.cadence = cadence;
+ // Recompute scheduling state to match the new cadence. Without this,
+ // a Manual -> Cron switch leaves next_fire_at = None and the ticker
+ // never picks the mission up; a Cron expression/timezone change
+ // keeps firing on the old schedule until the mission is paused and
+ // resumed. Clear next_fire_at for non-cron cadences so a stale
+ // value can't trigger an unrelated cron path. Reject cron schedules
+ // that are valid but have no future fire time so we don't persist
+ // an Active mission that can never run.
+ //
+ // Strict `next_cron_fire_required`: an `Err` here returns from
+ // `update_mission` BEFORE the `save_mission` call below, leaving
+ // the persisted record on its previous (valid) cadence. The
+ // `mission` local is dropped without ever being persisted —
+ // `save_mission` is the only persistence boundary in this
+ // function, so failing before it leaves the store untouched.
+ // Verified by `update_mission_rejects_switch_to_unschedulable_cron`.
+ mission.next_fire_at = match &mission.cadence {
+ MissionCadence::Cron {
+ expression,
+ timezone,
+ } => Some(next_cron_fire_required(expression, timezone.as_ref())?),
+ _ => None,
+ };
}
if let Some(channels) = updates.notify_channels {
mission.notify_channels = channels;
@@ -336,6 +469,10 @@ impl MissionManager {
.update_mission_status(id, MissionStatus::Paused)
.await?;
self.active.write().await.retain(|mid| *mid != id);
+ // Drop the in-memory cooldown entry — a paused mission can't fire,
+ // so the cooldown is dead state and would otherwise leak until the
+ // process restarts.
+ self.last_fire_attempt.write().await.remove(&id);
debug!(mission_id = %id, "mission paused");
Ok(())
}
@@ -347,7 +484,7 @@ impl MissionManager {
/// terminal states and must not be resurrected by a stray resume call,
/// so anything else is rejected with a `Store` error.
pub async fn resume_mission(&self, id: MissionId, user_id: &str) -> Result<(), EngineError> {
- let mission = self
+ let mut mission = self
.store
.load_mission(id)
.await?
@@ -373,9 +510,24 @@ impl MissionManager {
),
});
}
- self.store
- .update_mission_status(id, MissionStatus::Active)
- .await?;
+ // Mutate-and-save in a single round-trip. The previous implementation
+ // did `update_mission_status(Active)` and then a separate `load+save`
+ // to recompute next_fire_at — between the two writes, a concurrent
+ // `update_mission`/`fire_mission` could modify other fields that the
+ // second save would then silently overwrite with the stale reload.
+ mission.status = MissionStatus::Active;
+ if let MissionCadence::Cron {
+ ref expression,
+ ref timezone,
+ } = mission.cadence
+ {
+ // Reject Ok(None): resuming a cron mission whose schedule has no
+ // upcoming fire time would silently re-create the #1944 stuck
+ // state. Surface the error so the caller can fix the schedule.
+ mission.next_fire_at = Some(next_cron_fire_required(expression, timezone.as_ref())?);
+ }
+ mission.updated_at = chrono::Utc::now();
+ self.store.save_mission(&mission).await?;
let mut active = self.active.write().await;
if !active.contains(&id) {
active.push(id);
@@ -390,6 +542,9 @@ impl MissionManager {
.update_mission_status(id, MissionStatus::Completed)
.await?;
self.active.write().await.retain(|mid| *mid != id);
+ // Terminal state — drop the cooldown entry so the in-memory map
+ // doesn't accumulate an entry per mission ever fired.
+ self.last_fire_attempt.write().await.remove(&id);
self.evict_event_regex(id).await;
debug!(mission_id = %id, "mission completed");
Ok(())
@@ -544,14 +699,113 @@ impl MissionManager {
)
.await?;
+ // Capture the fire instant once and use it for both the persisted
+ // `last_fire_at` and the in-memory `last_fire_attempt` map. The two
+ // writes MUST share the same value: tick's stale-state detection
+ // compares them as equal-or-not to decide whether the cooldown
+ // applies, and using two separate `Utc::now()` calls would produce
+ // microsecond drift that breaks the equality check on the success
+ // path.
+ let fire_instant = chrono::Utc::now();
+
+ // Install the outcome watcher *before* persisting the mission update.
+ // The watcher only depends on `thread_id` (it joins via ThreadManager
+ // and reloads the mission record itself), so installing it first
+ // ensures a transient `save_mission` failure below cannot orphan the
+ // running thread by skipping the watcher install. Pass `fire_instant`
+ // through so the outcome processor can reconcile `last_fire_at`
+ // back to the original moment if the save below fails — without
+ // this the reconciled value would be the *outcome* time, which can
+ // be many seconds-to-hours later for long-running mission threads.
+ self.spawn_mission_outcome_watcher(id, thread_id, fire_instant);
+
// Record the thread + trigger payload in mission history
let mut updated = mission;
let user_id_for_rate = updated.user_id.clone();
updated.record_thread(thread_id);
updated.threads_today += 1;
updated.last_trigger_payload = trigger_payload;
- updated.last_fire_at = Some(chrono::Utc::now());
- self.store.save_mission(&updated).await?;
+ // Advance next_fire_at for cron missions so the ticker schedules the
+ // next cycle. Computed from `now()`, not from the previous fire time:
+ // if a tick was delayed (process down, busy loop) and several windows
+ // are missed, they coalesce into a single fire here rather than
+ // backfilling each missed slot. This is the catch-up semantics we want
+ // for long-running missions.
+ //
+ // Lenient `next_cron_fire` (not `_required`): a parse error here is
+ // unlikely (the expression validated at create time) but possible if
+ // persisted data is corrupt. We log and preserve the existing
+ // `next_fire_at` rather than aborting fire — the thread is already
+ // running and the watcher is already installed, and at worst the
+ // schedule is delayed by one cycle until the next tick.
+ //
+ // `cron_advanced` tracks whether scheduling actually progressed. When
+ // false (parse error on a corrupt expression), we deliberately leave
+ // `last_fire_at` at its OLD persisted value. The in-memory
+ // `last_fire_attempt[mid]` will still be set to `fire_instant` below,
+ // so the in-memory vs persisted mismatch arms tick's cooldown via
+ // the same code path as a save failure. Without this, a corrupt
+ // expression with a past `next_fire_at` would re-fire on every tick
+ // (cooldown matched, schedule never advanced) and exhaust the daily
+ // budget — same root cause as #1944.
+ let mut cron_advanced = true;
+ if let MissionCadence::Cron {
+ ref expression,
+ ref timezone,
+ } = updated.cadence
+ {
+ match next_cron_fire(expression, timezone.as_ref()) {
+ Ok(next) => updated.next_fire_at = next,
+ Err(e) => {
+ cron_advanced = false;
+ debug!(
+ mission_id = %id,
+ expression = %expression,
+ error = %e,
+ "failed to advance next_fire_at after fire; preserving existing value and arming cooldown via mismatch"
+ );
+ }
+ }
+ }
+ if cron_advanced {
+ updated.last_fire_at = Some(fire_instant);
+ }
+
+ // Arm the in-memory cooldown BEFORE the persistence call, not after.
+ //
+ // Why first: a concurrent tick observing the post-`save_mission`
+ // state but pre-`last_fire_attempt`-insert state would see the
+ // freshly-persisted `last_fire_at = fire_instant` AND no in-memory
+ // entry, evaluate `is_some_and(...)` to false, and (if the schedule
+ // is still in the past) re-fire immediately. Inserting first closes
+ // that race: while save is in flight, in-memory has `fire_instant`
+ // and persisted still has the OLD `last_fire_at`, so tick sees a
+ // mismatch and arms the cooldown. Once save lands the values match
+ // (success path) or stay mismatched (failure path) — both correct.
+ //
+ // Held briefly under the write lock; the map is keyed by mission ID
+ // and only mutated here, in tick (prune), and in pause/complete.
+ self.last_fire_attempt
+ .write()
+ .await
+ .insert(id, fire_instant);
+
+ // Persistence is best-effort: if save_mission fails on a transient store
+ // error, the thread is already running and the outcome watcher is already
+ // installed (above), so failing here would orphan the work AND — for cron
+ // cadences — leave next_fire_at un-advanced, causing the next tick to
+ // re-fire the same mission in a runaway loop. Log and continue. The
+ // caller still gets Ok(Some(thread_id)) so the spawned thread is visible.
+ // The in-memory `last_fire_attempt` cooldown above catches runaway re-fires
+ // by comparing in-memory vs persisted `last_fire_at` (see tick).
+ if let Err(e) = self.store.save_mission(&updated).await {
+ debug!(
+ mission_id = %id,
+ thread_id = %thread_id,
+ error = %e,
+ "failed to persist mission update after fire; thread is running and watched, in-memory cooldown will suppress re-fire"
+ );
+ }
// Now that the spawn + persist have succeeded, consume a slot in
// the per-user rate window. Doing this here (rather than at the
@@ -560,7 +814,6 @@ impl MissionManager {
self.record_user_rate(&user_id_for_rate).await;
debug!(mission_id = %id, thread_id = %thread_id, "mission fired");
- self.spawn_mission_outcome_watcher(id, thread_id);
Ok(Some(thread_id))
}
@@ -593,7 +846,11 @@ impl MissionManager {
self.thread_manager
.resume_thread(thread_id, user_id.to_string(), None, None, None)
.await?;
- self.spawn_mission_outcome_watcher(mission_id, thread_id);
+ // Resumed threads are already in `thread_history` from the
+ // original fire, so the outcome processor will see
+ // `needs_reconcile = false` and never read this value. Pass
+ // `now` as a safe placeholder; nothing depends on it.
+ self.spawn_mission_outcome_watcher(mission_id, thread_id, chrono::Utc::now());
resumed.push(thread_id);
}
}
@@ -1104,6 +1361,18 @@ impl MissionManager {
);
mission.metadata = serde_json::json!({"self_improvement": true});
mission.max_threads_per_day = 5;
+ // Future-proof: today this helper only ever uses OnSystemEvent, but if
+ // a future caller passes a Cron cadence the same `next_fire_at = None`
+ // bug that #1944 fixed in `create_mission` would silently re-emerge
+ // here. Compute next_fire_at on construction so this helper can never
+ // produce a stuck cron mission.
+ if let MissionCadence::Cron {
+ ref expression,
+ ref timezone,
+ } = mission.cadence
+ {
+ mission.next_fire_at = Some(next_cron_fire_required(expression, timezone.as_ref())?);
+ }
let id = mission.id;
self.store.save_mission(&mission).await?;
@@ -1300,6 +1569,17 @@ impl MissionManager {
mission.success_criteria = Some(success_criteria.into());
mission.metadata = serde_json::json!({metadata_key: true});
mission.max_threads_per_day = max_per_day;
+ // Future-proof: today every caller passes OnSystemEvent, but a future
+ // caller passing Cron would silently re-introduce the `next_fire_at =
+ // None` bug that #1944 fixed in `create_mission`. Compute it here so
+ // this helper can never produce a stuck cron mission.
+ if let MissionCadence::Cron {
+ ref expression,
+ ref timezone,
+ } = mission.cadence
+ {
+ mission.next_fire_at = Some(next_cron_fire_required(expression, timezone.as_ref())?);
+ }
let id = mission.id;
self.store.save_mission(&mission).await?;
@@ -1318,11 +1598,30 @@ impl MissionManager {
let active_ids = self.active.read().await.clone();
let mut spawned = Vec::new();
let now = chrono::Utc::now();
+ let cooldown =
+ chrono::Duration::from_std(FIRE_COOLDOWN).unwrap_or(chrono::Duration::zero());
+
+ // Opportunistic prune of `last_fire_attempt`: drop entries whose
+ // cooldown window has already elapsed. This catches stragglers from
+ // missions that were removed without going through the graceful
+ // pause/complete paths (e.g. crash recovery, direct store edits) so
+ // the map can never grow unbounded over a long-lived process.
+ {
+ let mut map = self.last_fire_attempt.write().await;
+ map.retain(|_, last| now.signed_duration_since(*last) < cooldown);
+ }
for mid in active_ids {
- let mission = match self.store.load_mission(mid).await? {
- Some(m) if m.status == MissionStatus::Active => m,
- _ => continue,
+ // Per-mission error isolation: a transient store/load error or a
+ // single fire failure must not abort the entire tick — the other
+ // active missions still need their chance to fire on this cycle.
+ let mission = match self.store.load_mission(mid).await {
+ Ok(Some(m)) if m.status == MissionStatus::Active => m,
+ Ok(_) => continue,
+ Err(e) => {
+ debug!(mission_id = %mid, error = %e, "tick: failed to load mission; skipping");
+ continue;
+ }
};
let should_fire = match &mission.cadence {
@@ -1340,12 +1639,72 @@ impl MissionManager {
continue;
}
- // `fire_mission` enforces cooldown_secs and max_concurrent
- // independently of the cron next_fire_at, so a cron mission whose
- // schedule fires faster than its cooldown will simply skip the
- // intervening firings rather than backlog them.
- if let Some(tid) = self.fire_mission(mid, &mission.user_id, None).await? {
- spawned.push(tid);
+ // In-memory cooldown — only armed when we can prove
+ // `fire_mission`'s post-spawn state didn't make scheduling
+ // progress. The detection: `fire_mission` writes the **same**
+ // instant to both `last_fire_attempt[mid]` (always, before
+ // save_mission) and the persisted `Mission.last_fire_at` (only
+ // when both `save_mission` succeeds *and* cron advance
+ // succeeded). The two paths that leave the values *unequal*:
+ //
+ // - `save_mission` failed → persisted `last_fire_at` still
+ // holds the OLD value (or None).
+ // - The cron expression couldn't be parsed (corrupt
+ // persisted state) → fire_mission deliberately leaves
+ // `last_fire_at` at the OLD value so this same mismatch
+ // arms the cooldown without inventing a new signal.
+ //
+ // On the success path the two values match and tick treats
+ // the cooldown as transparent — a normally-firing every-minute
+ // cron passes through the check regardless of how short the
+ // schedule is. Once the outcome processor reconciles
+ // `last_fire_at` back to the in-memory instant the mismatch
+ // resolves even before the 90 s window elapses.
+ //
+ // **Precision requirement (load-bearing):** the equality check
+ // requires the `Store` implementation to round-trip
+ // `DateTime` without precision loss. The bridge's
+ // `HybridStoreAdapter::load_mission` returns from an in-memory
+ // `HashMap` cache populated by `save_mission`,
+ // so it preserves nanosecond precision. JSON persistence via
+ // `serde` also preserves nanoseconds via RFC3339. A future
+ // backend that truncates timestamps (e.g. PostgreSQL TIMESTAMPTZ
+ // → microseconds) would silently break the success-path detection
+ // and arm the cooldown on every fire — the comparison would need
+ // to be relaxed to "within one microsecond" before that lands.
+ let on_cooldown =
+ self.last_fire_attempt
+ .read()
+ .await
+ .get(&mid)
+ .is_some_and(|in_mem_last| {
+ now.signed_duration_since(*in_mem_last) < cooldown
+ && mission.last_fire_at != Some(*in_mem_last)
+ });
+ if on_cooldown {
+ debug!(
+ mission_id = %mid,
+ "tick: detected stale persisted last_fire_at after fire; suppressing re-fire until reconcile"
+ );
+ continue;
+ }
+
+ // Per-mission error isolation: a single fire failure must not
+ // abort the entire tick — the other active missions still need
+ // their chance on this cycle. `fire_mission` enforces
+ // `cooldown_secs` and `max_concurrent` independently of the cron
+ // next_fire_at, so a cron mission whose schedule fires faster
+ // than its cooldown will simply skip the intervening firings
+ // rather than backlog them. Cron missions are fired with the
+ // mission's own user_id so artifacts stay tenant-scoped.
+ match self.fire_mission(mid, &mission.user_id, None).await {
+ Ok(Some(tid)) => spawned.push(tid),
+ Ok(None) => {}
+ Err(e) => debug!(
+ mission_id = %mid,
+ error = %e,
+ "tick: fire_mission failed; continuing with remaining missions"
+ ),
}
}
@@ -1495,7 +1854,12 @@ impl MissionManager {
}
}
- fn spawn_mission_outcome_watcher(&self, mission_id: MissionId, thread_id: ThreadId) {
+ fn spawn_mission_outcome_watcher(
+ &self,
+ mission_id: MissionId,
+ thread_id: ThreadId,
+ original_fire_at: chrono::DateTime,
+ ) {
let tm = Arc::clone(&self.thread_manager);
let store = Arc::clone(&self.store);
let notification_tx = self.notification_tx.clone();
@@ -1508,6 +1872,7 @@ impl MissionManager {
thread_id,
&outcome,
¬ification_tx,
+ Some(original_fire_at),
)
.await
{
@@ -1665,8 +2030,15 @@ async fn process_mission_outcome(
outcome: &ThreadOutcome,
) -> Result<(), EngineError> {
let (notification_tx, _) = tokio::sync::broadcast::channel(1);
- process_mission_outcome_and_notify(store, mission_id, thread_id, outcome, ¬ification_tx)
- .await
+ process_mission_outcome_and_notify(
+ store,
+ mission_id,
+ thread_id,
+ outcome,
+ ¬ification_tx,
+ None,
+ )
+ .await
}
async fn process_mission_outcome_and_notify(
@@ -1675,12 +2047,76 @@ async fn process_mission_outcome_and_notify(
thread_id: ThreadId,
outcome: &ThreadOutcome,
notification_tx: &tokio::sync::broadcast::Sender,
+ original_fire_at: Option>,
) -> Result<(), EngineError> {
let mut mission = match store.load_mission(mission_id).await? {
Some(m) => m,
None => return Ok(()),
};
+ // Reconcile fire-accounting fields that `fire_mission` failed to persist.
+ //
+ // `fire_mission` is best-effort about its post-spawn `save_mission`: a
+ // transient store error there leaves the persisted mission missing this
+ // thread's record (`thread_history`, `threads_today`, `last_fire_at`,
+ // and — for cron cadences — the advanced `next_fire_at`). The in-memory
+ // `last_fire_attempt` cooldown holds the runaway-re-fire path closed
+ // for ~90 s, but once the cooldown elapses tick would otherwise re-fire
+ // against the stale persisted state. The outcome processor is the
+ // natural reconciliation point: by the time we run, the thread has
+ // completed and we know exactly which `thread_id` should be present.
+ // Append idempotently — repeated invocations or replays are safe — and
+ // immediately overwrite our save below, achieving eventual consistency
+ // for transient store failures even after retries are exhausted.
+ let needs_reconcile = !mission.thread_history.contains(&thread_id);
+ if needs_reconcile {
+ debug!(
+ mission_id = %mission_id,
+ thread_id = %thread_id,
+ "outcome processor: reconciling fire-accounting fields missing from persisted mission (fire_mission save likely failed)"
+ );
+ // `record_thread` also bumps `updated_at`; matches the fire_mission
+ // path so the two routes don't diverge on field-mutation patterns.
+ mission.record_thread(thread_id);
+ mission.threads_today = mission.threads_today.saturating_add(1);
+ // Reconcile `last_fire_at` back to the **original** fire instant
+ // when we know it (passed through from fire_mission via the
+ // outcome watcher). Otherwise fall back to `now` as a conservative
+ // approximation. Using the original instant matters for users with
+ // a configured `cooldown_secs`: if the thread ran for N seconds,
+ // a `now`-based reconcile would extend the user's cooldown window
+ // by N, gradually drifting the schedule.
+ mission.last_fire_at = Some(original_fire_at.unwrap_or_else(chrono::Utc::now));
+ // For cron missions, advance `next_fire_at` so the ticker doesn't
+ // immediately re-fire against the stale schedule. Use the lenient
+ // `next_cron_fire` (not `_required`) — a corrupt expression here
+ // should not block the outcome save.
+ if let MissionCadence::Cron {
+ ref expression,
+ ref timezone,
+ } = mission.cadence
+ {
+ let now = chrono::Utc::now();
+ let needs_advance = mission.next_fire_at.is_none_or(|next| next <= now);
+ if needs_advance {
+ match next_cron_fire(expression, timezone.as_ref()) {
+ Ok(Some(next)) => mission.next_fire_at = Some(next),
+ Ok(None) => debug!(
+ mission_id = %mission_id,
+ expression = %expression,
+ "reconcile: cron has no upcoming fire time; leaving next_fire_at unset"
+ ),
+ Err(e) => debug!(
+ mission_id = %mission_id,
+ expression = %expression,
+ error = %e,
+ "reconcile: failed to recompute next_fire_at; leaving as-is"
+ ),
+ }
+ }
+ }
+ }
+
// Build notification fields while processing the outcome.
let mut notify_response: Option = None;
let mut is_error = false;
@@ -2515,7 +2951,6 @@ mod tests {
use std::collections::HashMap;
use std::sync::Mutex;
- use std::time::Duration;
use crate::capability::lease::LeaseManager;
use crate::capability::policy::PolicyEngine;
@@ -2542,6 +2977,13 @@ mod tests {
threads: tokio::sync::RwLock>,
missions: tokio::sync::RwLock>,
docs: tokio::sync::RwLock>,
+ /// Optional gate that blocks the next `save_mission` call until
+ /// the test releases it. Used by `fire_mission_arms_cooldown_before_save`
+ /// to deterministically observe the in-flight save state.
+ save_mission_gate: tokio::sync::Mutex>>,
+ /// Notified when `save_mission` enters the gated wait so the test
+ /// knows save is in progress (rather than not yet called).
+ save_mission_started: tokio::sync::Notify,
}
impl TestStore {
@@ -2550,8 +2992,18 @@ mod tests {
threads: tokio::sync::RwLock::new(HashMap::new()),
missions: tokio::sync::RwLock::new(HashMap::new()),
docs: tokio::sync::RwLock::new(Vec::new()),
+ save_mission_gate: tokio::sync::Mutex::new(None),
+ save_mission_started: tokio::sync::Notify::new(),
}
}
+
+ /// Block the next `save_mission` call. Returns a sender the test
+ /// must signal once it's done observing the in-flight state.
+ async fn block_next_save_mission(&self) -> tokio::sync::oneshot::Sender<()> {
+ let (tx, rx) = tokio::sync::oneshot::channel();
+ *self.save_mission_gate.lock().await = Some(rx);
+ tx
+ }
}
fn make_skill_doc(project_id: ProjectId, user_id: &str, name: &str) -> MemoryDoc {
@@ -2671,6 +3123,14 @@ mod tests {
// ── Mission (fully implemented) ──
async fn save_mission(&self, mission: &Mission) -> Result<(), EngineError> {
+ // Honor the test gate if one is installed. Take the receiver out
+ // of the slot so subsequent saves are unblocked by default — the
+ // gate is one-shot per `block_next_save_mission` call.
+ let gate = self.save_mission_gate.lock().await.take();
+ if let Some(rx) = gate {
+ self.save_mission_started.notify_one();
+ let _ = rx.await;
+ }
self.missions
.write()
.await
@@ -3010,7 +3470,7 @@ mod tests {
let mgr = make_mission_manager(Arc::clone(&store) as Arc);
let project_id = ProjectId::new();
- // Create a cron mission with next_fire_at in the past
+ // Create a cron mission — create_mission now computes next_fire_at
let id = mgr
.create_mission(
project_id,
@@ -3026,7 +3486,14 @@ mod tests {
.await
.unwrap();
- // Set next_fire_at to the past so tick() will fire it
+ // Verify next_fire_at was populated by create_mission
+ let mission = mgr.get_mission(id).await.unwrap().unwrap();
+ assert!(
+ mission.next_fire_at.is_some(),
+ "create_mission should compute next_fire_at for cron cadence"
+ );
+
+ // Move next_fire_at to the past so tick() will fire it
{
let mut missions = store.missions.write().await;
if let Some(mission) = missions.get_mut(&id) {
@@ -3777,8 +4244,7 @@ mod tests {
#[tokio::test]
async fn shared_mission_management_is_open_at_engine_layer() {
// Contract pinned by this test (matches the doc-comment on
- // Contract pinned (matches doc-comment on `resume_mission` and the
- // ownership tightening in PR #2126/#2130):
+ // `resume_mission` and the ownership tightening in PR #2126/#2130):
//
// "Shared missions can only be managed by shared owners
// (system user)."
@@ -4589,6 +5055,7 @@ mod tests {
error: "container exited 137".into(),
},
mgr.notification_tx_for_test(),
+ None,
)
.await
.unwrap();
@@ -4614,6 +5081,7 @@ mod tests {
synthetic_thread_id,
&ThreadOutcome::MaxIterations,
mgr.notification_tx_for_test(),
+ None,
)
.await
.unwrap();
@@ -4624,6 +5092,119 @@ mod tests {
assert!(notification.is_error, "MaxIterations must set is_error");
}
+ #[tokio::test]
+ async fn outcome_processor_reconciles_missing_fire_accounting() {
+ // Regression: when `fire_mission`'s post-spawn `save_mission` fails,
+ // the persisted mission is missing the new thread_id, threads_today
+ // bump, last_fire_at stamp, and (for cron) advanced next_fire_at.
+ // The outcome processor must reconcile these fields the next time
+ // it runs so the durable state catches up — otherwise tick re-fires
+ // against the stale schedule once the in-memory cooldown elapses.
+ let store = Arc::new(TestStore::new());
+ let mgr = make_mission_manager(Arc::clone(&store) as Arc);
+ let project_id = ProjectId::new();
+
+ // Create a cron mission with `next_fire_at` already in the past, to
+ // mimic the post-failed-fire state directly. (Going through
+ // `fire_mission` with a fault-injecting store would require a new
+ // TestStore variant; this is the equivalent end state.)
+ let id = mgr
+ .create_mission(
+ project_id,
+ "alice",
+ "reconcile-test",
+ "g",
+ MissionCadence::Cron {
+ expression: "* * * * *".into(),
+ timezone: None,
+ },
+ vec![],
+ )
+ .await
+ .unwrap();
+ {
+ let mut missions = store.missions.write().await;
+ let mission = missions.get_mut(&id).unwrap();
+ mission.next_fire_at = Some(chrono::Utc::now() - chrono::Duration::seconds(120));
+ mission.threads_today = 0;
+ mission.thread_history.clear();
+ mission.last_fire_at = None;
+ }
+
+ // Run the outcome processor with a thread_id that the persisted
+ // mission has never seen — exactly the state a failed `save_mission`
+ // would leave us in.
+ let orphan_thread_id = crate::types::thread::ThreadId::new();
+ // Pass an explicit `original_fire_at` so the test exercises the
+ // production-equivalent path where fire_mission's instant flows
+ // through the watcher into reconcile (instead of falling back to
+ // `now`).
+ let original_fire_at = chrono::Utc::now() - chrono::Duration::seconds(30);
+ process_mission_outcome_and_notify(
+ &(Arc::clone(&store) as Arc),
+ id,
+ orphan_thread_id,
+ &ThreadOutcome::Completed {
+ response: Some("done".into()),
+ },
+ mgr.notification_tx_for_test(),
+ Some(original_fire_at),
+ )
+ .await
+ .unwrap();
+
+ let reloaded = mgr.get_mission(id).await.unwrap().unwrap();
+ assert!(
+ reloaded.thread_history.contains(&orphan_thread_id),
+ "outcome processor must idempotently append the missing thread_id"
+ );
+ assert_eq!(
+ reloaded.threads_today, 1,
+ "threads_today must catch up after reconcile"
+ );
+ assert_eq!(
+ reloaded.last_fire_at,
+ Some(original_fire_at),
+ "last_fire_at must be reconciled to the original fire instant, not `now`"
+ );
+ assert!(
+ reloaded
+ .next_fire_at
+ .is_some_and(|next| next > chrono::Utc::now()),
+ "next_fire_at must be advanced past now() after reconcile, got {:?}",
+ reloaded.next_fire_at
+ );
+
+ // Reconcile is idempotent: replaying with the same thread_id must
+ // not double-count threads_today or duplicate the history entry.
+ process_mission_outcome_and_notify(
+ &(Arc::clone(&store) as Arc),
+ id,
+ orphan_thread_id,
+ &ThreadOutcome::Completed {
+ response: Some("done".into()),
+ },
+ mgr.notification_tx_for_test(),
+ Some(original_fire_at),
+ )
+ .await
+ .unwrap();
+ let reloaded = mgr.get_mission(id).await.unwrap().unwrap();
+ assert_eq!(
+ reloaded
+ .thread_history
+ .iter()
+ .filter(|t| **t == orphan_thread_id)
+ .count(),
+ 1,
+ "thread_history must not duplicate on replay"
+ );
+ assert_eq!(
+ reloaded.threads_today, 1,
+ "threads_today must not double-count on replay"
+ );
+ }
+
/// A pattern that fails to compile (or exceeds the size cap) must be
/// logged and never match — it must not panic, hang, or fall through
/// to a substring search.
@@ -4670,100 +5251,648 @@ mod tests {
);
}
- #[test]
- fn conversation_insights_count_only_done_threads() {
- assert!(should_count_for_conversation_insights(ThreadState::Done));
- assert!(!should_count_for_conversation_insights(ThreadState::Failed));
- }
+ // ── Cron scheduling tests (#1944) ─────────────────────────
- #[test]
- fn build_skill_gap_payload_uses_active_skill_provenance() {
+ #[tokio::test]
+ async fn create_cron_mission_sets_next_fire_at() {
+ let store = Arc::new(TestStore::new());
+ let mgr = make_mission_manager(Arc::clone(&store) as Arc);
let project_id = ProjectId::new();
- let mut thread = Thread::new(
- "repair a github workflow",
- ThreadType::Foreground,
- project_id,
- "alice",
- ThreadConfig::default(),
- );
- thread.state = ThreadState::Done;
- let skill_doc_id = DocId::new();
- thread
- .set_active_skills(&[ActiveSkillProvenance {
- doc_id: skill_doc_id,
- name: "github-pr-workflow".to_string(),
- version: 3,
- snippet_names: vec!["list_prs".to_string()],
- force_activated: false,
- }])
- .unwrap();
- thread.add_event(crate::types::event::EventKind::ActionFailed {
- step_id: StepId::new(),
- action_name: "shell".to_string(),
- call_id: "call_1".to_string(),
- error: "gh auth status: not authenticated".to_string(),
- params_summary: None,
- });
- let trace = crate::executor::trace::build_trace(&thread);
- let active_skills = thread.active_skills();
- let payload = build_skill_gap_payload(&thread, &trace, &active_skills).unwrap();
+ let id = mgr
+ .create_mission(
+ project_id,
+ "test-user",
+ "cron test",
+ "periodic goal",
+ MissionCadence::Cron {
+ expression: "0 */6 * * *".into(),
+ timezone: None,
+ },
+ Vec::new(),
+ )
+ .await
+ .unwrap();
- assert_eq!(
- payload["active_skills"][0]["doc_id"],
- serde_json::Value::String(skill_doc_id.0.to_string())
+ let mission = mgr.get_mission(id).await.unwrap().unwrap();
+ assert!(
+ mission.next_fire_at.is_some(),
+ "cron mission should have next_fire_at computed on creation"
);
- let hints = payload["repair_hints"].as_array().unwrap();
assert!(
- hints
- .iter()
- .any(|hint| hint.as_str() == Some("missing_prerequisite")),
- "repair hints should include missing_prerequisite: {payload}"
+ mission.next_fire_at.unwrap() > chrono::Utc::now(),
+ "next_fire_at should be in the future"
);
}
- #[test]
- fn build_skill_gap_payload_preserves_recoverable_auth_prerequisite_hints() {
+ #[tokio::test]
+ async fn create_manual_mission_has_no_next_fire_at() {
+ let store = Arc::new(TestStore::new());
+ let mgr = make_mission_manager(Arc::clone(&store) as Arc);
let project_id = ProjectId::new();
- let mut thread = Thread::new(
- "repair a github workflow",
- ThreadType::Foreground,
- project_id,
- "alice",
- ThreadConfig::default(),
- );
- thread.state = ThreadState::Done;
- thread
- .set_active_skills(&[ActiveSkillProvenance {
- doc_id: DocId::new(),
- name: "github-pr-workflow".to_string(),
- version: 3,
- snippet_names: vec![],
- force_activated: false,
- }])
- .unwrap();
- thread.add_event(crate::types::event::EventKind::ActionFailed {
- step_id: StepId::new(),
- action_name: "shell".to_string(),
- call_id: "call_1".to_string(),
- error: "authentication required for credential github".to_string(),
- params_summary: None,
- });
- let trace = crate::executor::trace::build_trace(&thread);
- let payload = build_skill_gap_payload(&thread, &trace, &thread.active_skills()).unwrap();
- let hints = payload["repair_hints"].as_array().unwrap();
+ let id = mgr
+ .create_mission(
+ project_id,
+ "test-user",
+ "manual test",
+ "goal",
+ MissionCadence::Manual,
+ Vec::new(),
+ )
+ .await
+ .unwrap();
+ let mission = mgr.get_mission(id).await.unwrap().unwrap();
assert!(
- hints
- .iter()
- .any(|hint| hint.as_str() == Some("missing_prerequisite")),
- "recoverable auth failures should still produce missing_prerequisite: {payload}"
+ mission.next_fire_at.is_none(),
+ "manual mission should not have next_fire_at"
);
}
- #[test]
- fn learning_terminal_state_accepts_failed_threads() {
+ #[tokio::test]
+ async fn fire_mission_advances_next_fire_at() {
+ let store = Arc::new(TestStore::new());
+ let mgr = make_mission_manager(Arc::clone(&store) as Arc);
+ let project_id = ProjectId::new();
+
+ let id = mgr
+ .create_mission(
+ project_id,
+ "test-user",
+ "cron advance",
+ "periodic goal",
+ MissionCadence::Cron {
+ expression: "* * * * *".into(),
+ timezone: None,
+ },
+ Vec::new(),
+ )
+ .await
+ .unwrap();
+
+ // Move next_fire_at to the past so tick fires it
+ {
+ let mut missions = store.missions.write().await;
+ if let Some(mission) = missions.get_mut(&id) {
+ mission.next_fire_at = Some(chrono::Utc::now() - chrono::Duration::seconds(60));
+ }
+ }
+
+ let spawned = mgr.tick("test-user").await.unwrap();
+ assert_eq!(spawned.len(), 1);
+
+ // After firing, next_fire_at should be advanced to the future
+ let mission = mgr.get_mission(id).await.unwrap().unwrap();
+ assert!(
+ mission.next_fire_at.is_some(),
+ "next_fire_at should be set after firing"
+ );
+ assert!(
+ mission.next_fire_at.unwrap() > chrono::Utc::now(),
+ "next_fire_at should be strictly in the future after firing"
+ );
+ }
+
+ #[tokio::test]
+ async fn resume_cron_mission_recomputes_next_fire_at() {
+ let store = Arc::new(TestStore::new());
+ let mgr = make_mission_manager(Arc::clone(&store) as Arc);
+ let project_id = ProjectId::new();
+
+ let id = mgr
+ .create_mission(
+ project_id,
+ "test-user",
+ "cron resume",
+ "periodic goal",
+ MissionCadence::Cron {
+ expression: "0 */6 * * *".into(),
+ timezone: None,
+ },
+ Vec::new(),
+ )
+ .await
+ .unwrap();
+
+ // Pause the mission — this clears it from active list
+ mgr.pause_mission(id, "test-user").await.unwrap();
+
+ // Manually set next_fire_at to a stale past value
+ {
+ let mut missions = store.missions.write().await;
+ if let Some(mission) = missions.get_mut(&id) {
+ mission.next_fire_at = Some(chrono::Utc::now() - chrono::Duration::hours(24));
+ }
+ }
+
+ // Resume — should recompute next_fire_at
+ mgr.resume_mission(id, "test-user").await.unwrap();
+
+ let mission = mgr.get_mission(id).await.unwrap().unwrap();
+ assert!(
+ mission.next_fire_at.is_some(),
+ "resume should recompute next_fire_at for cron missions"
+ );
+ assert!(
+ mission.next_fire_at.unwrap() > chrono::Utc::now(),
+ "recomputed next_fire_at should be in the future"
+ );
+ }
+
+ #[tokio::test]
+ async fn update_mission_manual_to_cron_sets_next_fire_at() {
+ // Regression: a Manual -> Cron switch left next_fire_at = None and the
+ // mission never fired. update_mission must recompute the schedule.
+ let store = Arc::new(TestStore::new());
+ let mgr = make_mission_manager(Arc::clone(&store) as Arc);
+ let project_id = ProjectId::new();
+
+ let id = mgr
+ .create_mission(
+ project_id,
+ "test-user",
+ "starts manual",
+ "goal",
+ MissionCadence::Manual,
+ Vec::new(),
+ )
+ .await
+ .unwrap();
+
+ let mission = mgr.get_mission(id).await.unwrap().unwrap();
+ assert!(mission.next_fire_at.is_none());
+
+ mgr.update_mission(
+ id,
+ "test-user",
+ MissionUpdate {
+ cadence: Some(MissionCadence::Cron {
+ expression: "0 */6 * * *".into(),
+ timezone: None,
+ }),
+ ..Default::default()
+ },
+ )
+ .await
+ .unwrap();
+
+ let mission = mgr.get_mission(id).await.unwrap().unwrap();
+ assert!(
+ mission.next_fire_at.is_some(),
+ "Manual -> Cron update should compute next_fire_at"
+ );
+ assert!(
+ mission.next_fire_at.unwrap() > chrono::Utc::now(),
+ "next_fire_at should be in the future"
+ );
+ }
+
+ #[tokio::test]
+ async fn update_mission_cron_to_manual_clears_next_fire_at() {
+ // Regression: a stale next_fire_at must be cleared when switching away
+ // from Cron, otherwise the ticker could fire a non-cron mission.
+ let store = Arc::new(TestStore::new());
+ let mgr = make_mission_manager(Arc::clone(&store) as Arc);
+ let project_id = ProjectId::new();
+
+ let id = mgr
+ .create_mission(
+ project_id,
+ "test-user",
+ "starts cron",
+ "goal",
+ MissionCadence::Cron {
+ expression: "0 */6 * * *".into(),
+ timezone: None,
+ },
+ Vec::new(),
+ )
+ .await
+ .unwrap();
+ assert!(
+ mgr.get_mission(id)
+ .await
+ .unwrap()
+ .unwrap()
+ .next_fire_at
+ .is_some()
+ );
+
+ mgr.update_mission(
+ id,
+ "test-user",
+ MissionUpdate {
+ cadence: Some(MissionCadence::Manual),
+ ..Default::default()
+ },
+ )
+ .await
+ .unwrap();
+
+ let mission = mgr.get_mission(id).await.unwrap().unwrap();
+ assert!(
+ mission.next_fire_at.is_none(),
+ "non-cron cadence must clear next_fire_at"
+ );
+ }
+
+ #[tokio::test]
+ async fn create_cron_mission_with_timezone_uses_tz_for_schedule() {
+ // Regression: every other cron test in this file passes timezone: None,
+ // so the tz path is only exercised at the unit level inside types/mission.
+ // This test threads a real ValidTimezone through MissionManager and
+ // asserts the resulting next_fire_at differs from the UTC equivalent —
+ // proving the bridge router → mission_create → next_cron_fire chain
+ // actually honors the user's timezone end-to-end.
+ let store = Arc::new(TestStore::new());
+ let mgr = make_mission_manager(Arc::clone(&store) as Arc);
+ let project_id = ProjectId::new();
+ let tz = crate::types::mission::ValidTimezone::parse("America/New_York").unwrap();
+
+ let id_tz = mgr
+ .create_mission(
+ project_id,
+ "test-user",
+ "tz-aware",
+ "fires at 9am NY local",
+ MissionCadence::Cron {
+ expression: "0 9 * * *".into(),
+ timezone: Some(tz),
+ },
+ Vec::new(),
+ )
+ .await
+ .unwrap();
+
+ let id_utc = mgr
+ .create_mission(
+ project_id,
+ "test-user",
+ "tz-naive",
+ "fires at 9am UTC",
+ MissionCadence::Cron {
+ expression: "0 9 * * *".into(),
+ timezone: None,
+ },
+ Vec::new(),
+ )
+ .await
+ .unwrap();
+
+ let m_tz = mgr.get_mission(id_tz).await.unwrap().unwrap();
+ let m_utc = mgr.get_mission(id_utc).await.unwrap().unwrap();
+ let next_tz = m_tz.next_fire_at.expect("tz cron should have next_fire_at");
+ let next_utc = m_utc
+ .next_fire_at
+ .expect("utc cron should have next_fire_at");
+
+ // 9am NY = 13:00 or 14:00 UTC depending on DST; 9am UTC = 09:00 UTC.
+ use chrono::Timelike;
+ assert_ne!(
+ next_tz.hour(),
+ next_utc.hour(),
+ "tz-aware and tz-naive cron schedules must produce different UTC instants"
+ );
+ let tz_hour = next_tz.hour();
+ assert!(
+ tz_hour == 13 || tz_hour == 14,
+ "9am NY should land on UTC 13 or 14, got {tz_hour}"
+ );
+ assert_eq!(next_utc.hour(), 9, "9am UTC should land on UTC 9");
+ }
+
+ #[tokio::test]
+ async fn update_mission_cron_expression_change_recomputes_next_fire_at() {
+ // Regression: changing the cron expression must reset the schedule.
+ let store = Arc::new(TestStore::new());
+ let mgr = make_mission_manager(Arc::clone(&store) as Arc);
+ let project_id = ProjectId::new();
+
+ let id = mgr
+ .create_mission(
+ project_id,
+ "test-user",
+ "cron edit",
+ "goal",
+ MissionCadence::Cron {
+ // Year-locked to 2099 so the next fire is deterministically
+ // far in the future regardless of the calendar date the
+ // test runs on. The original `0 0 1 1 *` ("once a year on
+ // Jan 1") was racy around New Year's, when the yearly
+ // schedule's next fire could land within seconds and
+ // invert the `after < before` ordering below.
+ expression: "0 0 0 1 1 * 2099".into(),
+ timezone: None,
+ },
+ Vec::new(),
+ )
+ .await
+ .unwrap();
+ let before = mgr.get_mission(id).await.unwrap().unwrap().next_fire_at;
+
+ mgr.update_mission(
+ id,
+ "test-user",
+ MissionUpdate {
+ cadence: Some(MissionCadence::Cron {
+ expression: "* * * * *".into(), // every minute
+ timezone: None,
+ }),
+ ..Default::default()
+ },
+ )
+ .await
+ .unwrap();
+
+ let after = mgr.get_mission(id).await.unwrap().unwrap().next_fire_at;
+ assert!(after.is_some());
+ assert_ne!(
+ before, after,
+ "schedule must be recomputed on cadence change"
+ );
+ assert!(
+ after.unwrap() < before.unwrap(),
+ "every-minute schedule should fire sooner than once-a-year"
+ );
+ }
+
+ #[tokio::test]
+ async fn fire_mission_with_corrupt_cron_expression_does_not_orphan_thread() {
+ // Regression: previously fire_mission used `?` on next_cron_fire after
+ // spawning the thread. A persisted mission with a corrupt cron string
+ // would spawn the thread, then abort fire_mission with an Err — leaving
+ // the thread running with no entry in thread_history, no incremented
+ // budget, and (when also reordered) no outcome watcher installed.
+ let store = Arc::new(TestStore::new());
+ let mgr = make_mission_manager(Arc::clone(&store) as Arc);
+ let project_id = ProjectId::new();
+
+ let id = mgr
+ .create_mission(
+ project_id,
+ "test-user",
+ "corrupt cron",
+ "goal",
+ MissionCadence::Cron {
+ expression: "0 */6 * * *".into(),
+ timezone: None,
+ },
+ Vec::new(),
+ )
+ .await
+ .unwrap();
+
+ // Capture the original next_fire_at — we expect fire to *preserve* it
+ // (rather than replace with None or recompute) when the expression
+ // can't be parsed.
+ let original_next = mgr
+ .get_mission(id)
+ .await
+ .unwrap()
+ .unwrap()
+ .next_fire_at
+ .expect("create should populate next_fire_at");
+
+ // Corrupt the persisted expression directly in the test store.
+ {
+ let mut missions = store.missions.write().await;
+ if let Some(m) = missions.get_mut(&id)
+ && let MissionCadence::Cron {
+ ref mut expression, ..
+ } = m.cadence
+ {
+ *expression = "this is not a cron".to_string();
+ }
+ }
+
+ // Fire must succeed despite the corrupt expression.
+ let thread_id = mgr
+ .fire_mission(id, "test-user", None)
+ .await
+ .expect("fire_mission must not fail on corrupt cron");
+ assert!(thread_id.is_some(), "fire should spawn a thread");
+ let thread_id = thread_id.unwrap();
+
+ // The mission record must reflect the fire: thread tracked + budget
+ // incremented. Without the fix, save_mission was never reached.
+ let mission = mgr.get_mission(id).await.unwrap().unwrap();
+ assert!(
+ mission.thread_history.contains(&thread_id),
+ "thread should be recorded in thread_history"
+ );
+ assert_eq!(
+ mission.threads_today, 1,
+ "threads_today should be incremented even if next_fire_at couldn't recompute"
+ );
+ // next_fire_at should be preserved (not cleared) since we couldn't
+ // compute a new one.
+ assert_eq!(
+ mission.next_fire_at,
+ Some(original_next),
+ "next_fire_at must be preserved when next_cron_fire fails"
+ );
+ }
+
+ #[tokio::test]
+ async fn resume_mission_preserves_concurrent_field_changes() {
+ // Regression: resume_mission used to do update_mission_status() then a
+ // separate load+save round-trip to recompute next_fire_at. Now it does
+ // a single mutate-and-save with the mission already loaded for the
+ // ownership check, eliminating the extra interleave window.
+ //
+ // We can't deterministically exercise the TOCTOU window in a unit
+ // test, but we can assert the new contract: resume_mission writes the
+ // mission's other fields (e.g. threads_today) faithfully and does not
+ // depend on a separate update_mission_status round-trip succeeding.
+ let store = Arc::new(TestStore::new());
+ let mgr = make_mission_manager(Arc::clone(&store) as Arc);
+ let project_id = ProjectId::new();
+
+ let id = mgr
+ .create_mission(
+ project_id,
+ "test-user",
+ "resume preserve",
+ "goal",
+ MissionCadence::Cron {
+ expression: "0 */6 * * *".into(),
+ timezone: None,
+ },
+ Vec::new(),
+ )
+ .await
+ .unwrap();
+
+ mgr.pause_mission(id, "test-user").await.unwrap();
+
+ // Simulate a concurrent writer that bumps threads_today between pause
+ // and resume. With the old two-write resume path, the second
+ // load+save could clobber this. With the single-save path it cannot
+ // be clobbered by THIS resume call.
+ {
+ let mut missions = store.missions.write().await;
+ if let Some(m) = missions.get_mut(&id) {
+ m.threads_today = 7;
+ m.goal = "concurrently updated goal".to_string();
+ }
+ }
+
+ mgr.resume_mission(id, "test-user").await.unwrap();
+
+ let mission = mgr.get_mission(id).await.unwrap().unwrap();
+ assert_eq!(mission.status, MissionStatus::Active);
+ // The concurrent update happened *before* resume_mission's load, so
+ // the resume should observe and preserve those values rather than
+ // resetting to creation-time defaults.
+ assert_eq!(
+ mission.threads_today, 7,
+ "resume must not reset threads_today to a stale value"
+ );
+ assert_eq!(
+ mission.goal, "concurrently updated goal",
+ "resume must not clobber goal updated before its load"
+ );
+ assert!(
+ mission.next_fire_at.is_some(),
+ "resume should still recompute next_fire_at for cron"
+ );
+ }
+
+ #[tokio::test]
+ async fn ensure_mission_by_metadata_with_cron_cadence_computes_next_fire_at() {
+ // Regression: ensure_mission_by_metadata used to construct
+ // Mission::new + save_mission directly, bypassing the next_fire_at
+ // computation that create_mission performs. Today every caller passes
+ // OnSystemEvent so the bug is latent, but a future caller passing
+ // Cron would silently re-introduce the original `next_fire_at = None`
+ // bug that #1944 fixes.
+ let store = Arc::new(TestStore::new());
+ let mgr = make_mission_manager(Arc::clone(&store) as Arc);
+ let project_id = ProjectId::new();
+
+ let id = mgr
+ .ensure_mission_by_metadata(
+ project_id,
+ "test-user",
+ "synthetic_cron",
+ "synthetic-cron",
+ "synthetic goal",
+ MissionCadence::Cron {
+ expression: "0 9 * * *".into(),
+ timezone: None,
+ },
+ "synthetic criteria",
+ 3,
+ )
+ .await
+ .unwrap();
+
+ let mission = mgr.get_mission(id).await.unwrap().unwrap();
+ assert!(
+ mission.next_fire_at.is_some(),
+ "ensure_mission_by_metadata must compute next_fire_at for Cron cadence"
+ );
+ assert!(
+ mission.next_fire_at.unwrap() > chrono::Utc::now(),
+ "next_fire_at must be in the future"
+ );
+ }
+
+ #[test]
+ fn conversation_insights_count_only_done_threads() {
+ assert!(should_count_for_conversation_insights(ThreadState::Done));
+ assert!(!should_count_for_conversation_insights(ThreadState::Failed));
+ }
+
+ #[test]
+ fn build_skill_gap_payload_uses_active_skill_provenance() {
+ let project_id = ProjectId::new();
+ let mut thread = Thread::new(
+ "repair a github workflow",
+ ThreadType::Foreground,
+ project_id,
+ "alice",
+ ThreadConfig::default(),
+ );
+ thread.state = ThreadState::Done;
+ let skill_doc_id = DocId::new();
+ thread
+ .set_active_skills(&[ActiveSkillProvenance {
+ doc_id: skill_doc_id,
+ name: "github-pr-workflow".to_string(),
+ version: 3,
+ snippet_names: vec!["list_prs".to_string()],
+ force_activated: false,
+ }])
+ .unwrap();
+ thread.add_event(crate::types::event::EventKind::ActionFailed {
+ step_id: StepId::new(),
+ action_name: "shell".to_string(),
+ call_id: "call_1".to_string(),
+ error: "gh auth status: not authenticated".to_string(),
+ params_summary: None,
+ });
+
+ let trace = crate::executor::trace::build_trace(&thread);
+ let active_skills = thread.active_skills();
+ let payload = build_skill_gap_payload(&thread, &trace, &active_skills).unwrap();
+
+ assert_eq!(
+ payload["active_skills"][0]["doc_id"],
+ serde_json::Value::String(skill_doc_id.0.to_string())
+ );
+ let hints = payload["repair_hints"].as_array().unwrap();
+ assert!(
+ hints
+ .iter()
+ .any(|hint| hint.as_str() == Some("missing_prerequisite")),
+ "repair hints should include missing_prerequisite: {payload}"
+ );
+ }
+
+ #[test]
+ fn build_skill_gap_payload_preserves_recoverable_auth_prerequisite_hints() {
+ let project_id = ProjectId::new();
+ let mut thread = Thread::new(
+ "repair a github workflow",
+ ThreadType::Foreground,
+ project_id,
+ "alice",
+ ThreadConfig::default(),
+ );
+ thread.state = ThreadState::Done;
+ thread
+ .set_active_skills(&[ActiveSkillProvenance {
+ doc_id: DocId::new(),
+ name: "github-pr-workflow".to_string(),
+ version: 3,
+ snippet_names: vec![],
+ force_activated: false,
+ }])
+ .unwrap();
+ thread.add_event(crate::types::event::EventKind::ActionFailed {
+ step_id: StepId::new(),
+ action_name: "shell".to_string(),
+ call_id: "call_1".to_string(),
+ error: "authentication required for credential github".to_string(),
+ params_summary: None,
+ });
+
+ let trace = crate::executor::trace::build_trace(&thread);
+ let payload = build_skill_gap_payload(&thread, &trace, &thread.active_skills()).unwrap();
+ let hints = payload["repair_hints"].as_array().unwrap();
+
+ assert!(
+ hints
+ .iter()
+ .any(|hint| hint.as_str() == Some("missing_prerequisite")),
+ "recoverable auth failures should still produce missing_prerequisite: {payload}"
+ );
+ }
+
+ #[test]
+ fn learning_terminal_state_accepts_failed_threads() {
let failed_event = crate::types::event::EventKind::StateChanged {
from: ThreadState::Running,
to: ThreadState::Failed,
@@ -5164,4 +6293,460 @@ mod tests {
"read-only shell workflows should not trigger skill repair"
);
}
+
+ // ── next_cron_fire_required + cooldown regression tests ──────
+
+ /// A 7-field cron expression year-locked to a year that's already in the
+ /// past. `cron::Schedule` parses it cleanly but `upcoming(...).next()`
+ /// returns `None`, which is exactly the `Ok(None)` case the
+ /// `next_cron_fire_required` helper guards against.
+ const PAST_YEAR_CRON: &str = "0 0 0 1 1 * 2020";
+
+ #[tokio::test]
+ async fn create_mission_rejects_unschedulable_cron() {
+ // Regression: previously `create_mission` accepted Ok(None) and
+ // persisted an Active mission with `next_fire_at = None` — the
+ // exact failure mode of #1944. Now it must fail fast.
+ let store = Arc::new(TestStore::new());
+ let mgr = make_mission_manager(Arc::clone(&store) as Arc);
+ let project_id = ProjectId::new();
+
+ let err = mgr
+ .create_mission(
+ project_id,
+ "alice",
+ "unschedulable",
+ "g",
+ MissionCadence::Cron {
+ expression: PAST_YEAR_CRON.into(),
+ timezone: None,
+ },
+ vec![],
+ )
+ .await
+ .expect_err("create_mission must reject cron with no upcoming fire time");
+
+ assert!(
+ matches!(err, EngineError::InvalidCadence { .. }),
+ "expected InvalidCadence, got: {err:?}"
+ );
+
+ // No mission should be persisted, no entry in active.
+ assert!(store.missions.read().await.is_empty());
+ }
+
+ #[tokio::test]
+ async fn update_mission_rejects_switch_to_unschedulable_cron() {
+ let store = Arc::new(TestStore::new());
+ let mgr = make_mission_manager(Arc::clone(&store) as Arc);
+ let project_id = ProjectId::new();
+
+ let id = mgr
+ .create_mission(
+ project_id,
+ "alice",
+ "manual-then-cron",
+ "g",
+ MissionCadence::Manual,
+ vec![],
+ )
+ .await
+ .unwrap();
+
+ let err = mgr
+ .update_mission(
+ id,
+ "alice",
+ MissionUpdate {
+ cadence: Some(MissionCadence::Cron {
+ expression: PAST_YEAR_CRON.into(),
+ timezone: None,
+ }),
+ ..Default::default()
+ },
+ )
+ .await
+ .expect_err("update_mission must reject cron with no upcoming fire time");
+
+ assert!(matches!(err, EngineError::InvalidCadence { .. }));
+ // Original Manual cadence should be preserved on the persisted record.
+ let reloaded = mgr.get_mission(id).await.unwrap().unwrap();
+ assert!(matches!(reloaded.cadence, MissionCadence::Manual));
+ }
+
+ #[tokio::test]
+ async fn resume_mission_rejects_unschedulable_cron() {
+ // Build a paused cron mission whose schedule is fine, then mutate the
+ // persisted record to a year-locked expression and try to resume.
+ let store = Arc::new(TestStore::new());
+ let mgr = make_mission_manager(Arc::clone(&store) as Arc);
+ let project_id = ProjectId::new();
+
+ let id = mgr
+ .create_mission(
+ project_id,
+ "alice",
+ "resume-bad",
+ "g",
+ MissionCadence::Cron {
+ expression: "0 9 * * *".into(),
+ timezone: None,
+ },
+ vec![],
+ )
+ .await
+ .unwrap();
+ mgr.pause_mission(id, "alice").await.unwrap();
+
+ // Tamper with the persisted cadence to simulate a stored mission that
+ // can no longer fire (e.g. operator edited the database, or year-locked
+ // schedule rolled past).
+ {
+ let mut missions = store.missions.write().await;
+ if let Some(m) = missions.get_mut(&id) {
+ m.cadence = MissionCadence::Cron {
+ expression: PAST_YEAR_CRON.into(),
+ timezone: None,
+ };
+ }
+ }
+
+ let err = mgr
+ .resume_mission(id, "alice")
+ .await
+ .expect_err("resume_mission must reject cron with no upcoming fire time");
+ assert!(matches!(err, EngineError::InvalidCadence { .. }));
+
+ // Mission must remain paused — resume failed before any state change.
+ let reloaded = mgr.get_mission(id).await.unwrap().unwrap();
+ assert_eq!(reloaded.status, MissionStatus::Paused);
+ }
+
+ #[tokio::test]
+ async fn pause_and_complete_drop_cooldown_entry() {
+ // Regression: `last_fire_attempt` was previously only ever inserted,
+ // never pruned. Pausing or completing a mission must drop its
+ // cooldown entry so the in-memory map can't grow unbounded.
+ let store = Arc::new(TestStore::new());
+ let mgr = make_mission_manager(Arc::clone(&store) as Arc);
+ let project_id = ProjectId::new();
+
+ // Mission A — paused after a fire.
+ let id_a = mgr
+ .create_mission(
+ project_id,
+ "alice",
+ "pause-cleanup",
+ "g",
+ MissionCadence::Cron {
+ expression: "* * * * *".into(),
+ timezone: None,
+ },
+ vec![],
+ )
+ .await
+ .unwrap();
+ mgr.fire_mission(id_a, "alice", None).await.unwrap();
+ assert!(mgr.last_fire_attempt.read().await.contains_key(&id_a));
+ mgr.pause_mission(id_a, "alice").await.unwrap();
+ assert!(
+ !mgr.last_fire_attempt.read().await.contains_key(&id_a),
+ "pause_mission must drop the cooldown entry"
+ );
+
+ // Mission B — completed after a fire.
+ let id_b = mgr
+ .create_mission(
+ project_id,
+ "alice",
+ "complete-cleanup",
+ "g",
+ MissionCadence::Cron {
+ expression: "* * * * *".into(),
+ timezone: None,
+ },
+ vec![],
+ )
+ .await
+ .unwrap();
+ mgr.fire_mission(id_b, "alice", None).await.unwrap();
+ assert!(mgr.last_fire_attempt.read().await.contains_key(&id_b));
+ mgr.complete_mission(id_b).await.unwrap();
+ assert!(
+ !mgr.last_fire_attempt.read().await.contains_key(&id_b),
+ "complete_mission must drop the cooldown entry"
+ );
+ }
+
+ #[tokio::test]
+ async fn tick_cooldown_suppresses_re_fire_on_save_failure() {
+ // Regression for the runaway-re-fire concern: when save_mission fails
+ // after a successful spawn, the persisted `next_fire_at` AND
+ // `last_fire_at` stay at their pre-fire values, but the in-memory
+ // `last_fire_attempt[mid]` is set to the new fire instant. The
+ // mismatch between in-memory and persisted `last_fire_at` is what
+ // tells tick to arm the cooldown — without that signal every
+ // subsequent tick would re-fire the same mission and spawn
+ // duplicate threads up to the daily budget.
+ let store = Arc::new(TestStore::new());
+ let mgr = make_mission_manager(Arc::clone(&store) as Arc);
+ let project_id = ProjectId::new();
+
+ let id = mgr
+ .create_mission(
+ project_id,
+ "alice",
+ "cooldown",
+ "g",
+ MissionCadence::Cron {
+ expression: "* * * * *".into(),
+ timezone: None,
+ },
+ vec![],
+ )
+ .await
+ .unwrap();
+
+ // First fire arms the in-memory `last_fire_attempt` map.
+ let first = mgr.fire_mission(id, "alice", None).await.unwrap();
+ assert!(first.is_some(), "first fire should spawn a thread");
+
+ // Simulate the post-save-failure state explicitly: rewind
+ // `next_fire_at` into the past, reset `threads_today` so the budget
+ // can't be what's blocking, AND clobber `last_fire_at` so it no
+ // longer matches the in-memory `last_fire_attempt[mid]` instant.
+ // Together these mimic exactly the state a failed `save_mission`
+ // call would leave: in-memory recorded the fire, the store didn't.
+ {
+ let mut missions = store.missions.write().await;
+ let mission = missions.get_mut(&id).unwrap();
+ mission.next_fire_at = Some(chrono::Utc::now() - chrono::Duration::seconds(120));
+ mission.threads_today = 0;
+ mission.last_fire_at = None;
+ }
+
+ // tick must suppress the second fire — it can prove the persisted
+ // record is stale because in-memory last_fire_attempt holds an
+ // instant the persisted `last_fire_at` doesn't.
+ let spawned = mgr.tick("alice").await.unwrap();
+ assert!(
+ spawned.is_empty(),
+ "tick must skip mission whose persisted last_fire_at is stale, got: {spawned:?}"
+ );
+ }
+
+ #[tokio::test]
+ async fn fire_mission_arms_cooldown_before_save_mission() {
+ // Race regression: a concurrent tick observing the state between
+ // `save_mission` completion and the in-memory cooldown insert would
+ // see no cooldown entry, evaluate the mismatch check to false, and
+ // (if next_fire_at is in the past) re-fire immediately. Fix: insert
+ // the cooldown entry BEFORE calling save_mission.
+ //
+ // We verify the order by gating save_mission with a oneshot channel
+ // and asserting `last_fire_attempt[mid]` is already populated while
+ // save is still in flight.
+ use tokio::sync::Notify;
+
+ let store = Arc::new(TestStore::new());
+ let mgr = Arc::new(make_mission_manager(Arc::clone(&store) as Arc));
+ let project_id = ProjectId::new();
+
+ let id = mgr
+ .create_mission(
+ project_id,
+ "alice",
+ "race-test",
+ "g",
+ MissionCadence::Cron {
+ expression: "0 9 * * *".into(),
+ timezone: None,
+ },
+ vec![],
+ )
+ .await
+ .unwrap();
+
+ // Block the next save_mission. The first save_mission call below
+ // (from create_mission's path) already happened — `block_next_save_mission`
+ // installs the gate AFTER create, so it only catches fire_mission's save.
+ let release = store.block_next_save_mission().await;
+ let started = Arc::new(Notify::new());
+ let started_clone = Arc::clone(&started);
+ let store_clone = Arc::clone(&store);
+ // Spawn a watcher that translates `save_mission_started` into our own
+ // `started` notification. We can't share the TestStore's Notify across
+ // tasks via `notified()` cleanly without a permit, so wrap it.
+ tokio::spawn(async move {
+ store_clone.save_mission_started.notified().await;
+ started_clone.notify_one();
+ });
+
+ // Spawn fire_mission in a task — it will block inside save_mission.
+ let mgr_clone = Arc::clone(&mgr);
+ let fire_task = tokio::spawn(async move {
+ mgr_clone
+ .fire_mission(id, "alice", None)
+ .await
+ .expect("fire should succeed once save is unblocked")
+ });
+
+ // Wait until save_mission has begun (inside the gate).
+ started.notified().await;
+
+ // At this point save_mission is parked. The cooldown MUST already be
+ // armed because the fix inserts before save.
+ assert!(
+ mgr.last_fire_attempt.read().await.contains_key(&id),
+ "last_fire_attempt[mid] must be populated before save_mission begins; \
+ a concurrent tick in this window would otherwise see no cooldown entry"
+ );
+
+ // Unblock save and let fire_mission complete.
+ release.send(()).unwrap();
+ let thread_id = fire_task.await.unwrap();
+ assert!(thread_id.is_some(), "fire should spawn a thread");
+ }
+
+ #[tokio::test]
+ async fn tick_does_not_re_fire_corrupted_cron_within_cooldown_window() {
+ // Regression: when `next_cron_fire(expression)` returns Err inside
+ // fire_mission (corrupted persisted expression), the previous code
+ // stamped `last_fire_at = fire_instant` anyway. Save then succeeded
+ // with last_fire_at matching the in-memory value, so tick's
+ // mismatch detector saw "save succeeded" and the cooldown was
+ // never armed. With `next_fire_at` still in the past (preserved
+ // because the cron crate couldn't compute a new value), every
+ // subsequent tick re-fired the same mission until `max_threads_per_day`
+ // was exhausted.
+ //
+ // Fix: only stamp `last_fire_at = fire_instant` when cron actually
+ // advanced. On a parse error, leave persisted last_fire_at at its
+ // OLD value so the in-memory vs persisted mismatch arms the
+ // cooldown via the same code path as a save failure.
+ let store = Arc::new(TestStore::new());
+ let mgr = make_mission_manager(Arc::clone(&store) as Arc);
+ let project_id = ProjectId::new();
+
+ let id = mgr
+ .create_mission(
+ project_id,
+ "alice",
+ "corrupt-cron",
+ "g",
+ MissionCadence::Cron {
+ expression: "* * * * *".into(),
+ timezone: None,
+ },
+ vec![],
+ )
+ .await
+ .unwrap();
+
+ // Corrupt the persisted expression. fire_mission's cron advance
+ // call will fail and (with the fix) leave last_fire_at at the OLD
+ // value the test fixture started with.
+ {
+ let mut missions = store.missions.write().await;
+ let mission = missions.get_mut(&id).unwrap();
+ if let MissionCadence::Cron {
+ ref mut expression, ..
+ } = mission.cadence
+ {
+ *expression = "this is not a cron".to_string();
+ }
+ // Force next_fire_at into the past so should_fire is true.
+ mission.next_fire_at = Some(chrono::Utc::now() - chrono::Duration::seconds(60));
+ }
+
+ // First fire spawns a thread successfully despite the corrupt cron
+ // (regression test `fire_mission_with_corrupt_cron_expression_does_not_orphan_thread`
+ // pins this behavior). next_fire_at stays at its past value.
+ let first = mgr.fire_mission(id, "alice", None).await.unwrap();
+ assert!(
+ first.is_some(),
+ "first fire should spawn despite corrupt cron"
+ );
+
+ // tick must NOT re-fire the corrupted mission. Without the fix the
+ // cooldown was not armed (persisted last_fire_at == fire_instant ==
+ // in-memory), and tick would call fire_mission again every cycle.
+ let spawned = mgr.tick("alice").await.unwrap();
+ assert!(
+ spawned.is_empty(),
+ "tick must not re-fire a mission whose cron advance failed; \
+ cooldown should be armed via last_fire_at vs in-memory mismatch, \
+ got: {spawned:?}"
+ );
+
+ // Sanity: the persisted last_fire_at is still its pre-fire value
+ // (None for a freshly-created mission whose first fire failed to
+ // advance), confirming the mismatch-arming mechanism.
+ let reloaded = mgr.get_mission(id).await.unwrap().unwrap();
+ assert_eq!(
+ reloaded.last_fire_at, None,
+ "last_fire_at must NOT be stamped when cron advance failed"
+ );
+ }
+
+ #[tokio::test]
+ async fn tick_does_not_throttle_high_frequency_cron_after_successful_fire() {
+ // Regression for the inverse failure mode: the cooldown must NOT
+ // throttle a normally-firing high-frequency cron. An earlier
+ // implementation armed the cooldown unconditionally on every
+ // successful fire, which silently dropped roughly half of the
+ // events for `* * * * *` (every-minute) crons because the 60 s
+ // tick interval fell inside the 90 s cooldown window. The fix:
+ // only arm the cooldown when the persisted `last_fire_at` does
+ // NOT match the in-memory `last_fire_attempt` value — i.e. only
+ // in the failed-save regime.
+ let store = Arc::new(TestStore::new());
+ let mgr = make_mission_manager(Arc::clone(&store) as Arc);
+ let project_id = ProjectId::new();
+
+ let id = mgr
+ .create_mission(
+ project_id,
+ "alice",
+ "high-freq",
+ "g",
+ MissionCadence::Cron {
+ expression: "* * * * *".into(),
+ timezone: None,
+ },
+ vec![],
+ )
+ .await
+ .unwrap();
+
+ // First fire records the in-memory cooldown entry AND persists
+ // `last_fire_at = fire_instant`. The two values are the same
+ // (`fire_mission` uses a single `Utc::now()` for both writes).
+ let first = mgr.fire_mission(id, "alice", None).await.unwrap();
+ assert!(first.is_some(), "first fire should spawn a thread");
+
+ // Mimic "tick runs ~1 minute later, schedule advanced normally":
+ // rewind `next_fire_at` to a moment in the past that is STRICTLY
+ // LATER than the fire instant. Crucially, leave `last_fire_at`
+ // alone — it still equals `last_fire_attempt[mid]`, so the
+ // cooldown's mismatch detector says "save succeeded, do not
+ // throttle." Reset `threads_today` so the daily budget isn't
+ // what's blocking.
+ {
+ let mut missions = store.missions.write().await;
+ let mission = missions.get_mut(&id).unwrap();
+ // 1 ms earlier than now, but still later than the original
+ // fire instant since fire_mission ran microseconds ago.
+ mission.next_fire_at = Some(chrono::Utc::now() - chrono::Duration::milliseconds(1));
+ mission.threads_today = 0;
+ }
+
+ let spawned = mgr.tick("alice").await.unwrap();
+ assert_eq!(
+ spawned.len(),
+ 1,
+ "tick must fire a high-frequency cron after a successful fire — \
+ cooldown must not throttle the success path, got spawned={spawned:?}"
+ );
+ }
}
diff --git a/crates/ironclaw_engine/src/traits/effect.rs b/crates/ironclaw_engine/src/traits/effect.rs
index 42cbdd18334..1fed99bd6c7 100644
--- a/crates/ironclaw_engine/src/traits/effect.rs
+++ b/crates/ironclaw_engine/src/traits/effect.rs
@@ -9,6 +9,7 @@ use crate::types::error::EngineError;
use crate::types::project::ProjectId;
use crate::types::step::{ActionResult, StepId};
use crate::types::thread::{ThreadId, ThreadType};
+use ironclaw_common::ValidTimezone;
/// Contextual information about the thread requesting an effect.
///
@@ -25,6 +26,9 @@ pub struct ThreadExecutionContext {
/// The channel this thread's conversation originated from (e.g. "gateway", "repl").
/// Used by mission_create to default `notify_channels` to the current channel.
pub source_channel: Option,
+ /// Validated IANA timezone of the user (e.g. "America/New_York").
+ /// Used by mission_create to default cron timezone, and exposed to CodeAct scripts.
+ pub user_timezone: Option,
}
/// Abstraction over capability action execution.
diff --git a/crates/ironclaw_engine/src/types/error.rs b/crates/ironclaw_engine/src/types/error.rs
index 130dc41e4ce..7ab42db496e 100644
--- a/crates/ironclaw_engine/src/types/error.rs
+++ b/crates/ironclaw_engine/src/types/error.rs
@@ -26,6 +26,9 @@ pub enum EngineError {
#[error("effect execution error: {reason}")]
Effect { reason: String },
+ #[error("invalid cadence: {reason}")]
+ InvalidCadence { reason: String },
+
#[error("invalid state transition: {from} -> {to}")]
InvalidTransition { from: ThreadState, to: ThreadState },
diff --git a/crates/ironclaw_engine/src/types/mission.rs b/crates/ironclaw_engine/src/types/mission.rs
index f16b86fb5ee..19edf9de529 100644
--- a/crates/ironclaw_engine/src/types/mission.rs
+++ b/crates/ironclaw_engine/src/types/mission.rs
@@ -5,16 +5,20 @@
//! in response to events, or be triggered manually.
use std::collections::HashMap;
+use std::str::FromStr;
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use uuid::Uuid;
+use crate::types::error::EngineError;
use crate::types::project::ProjectId;
use crate::types::thread::ThreadId;
use super::{OwnerId, default_user_id};
+pub use ironclaw_common::ValidTimezone;
+
/// Strongly-typed mission identifier.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct MissionId(pub Uuid);
@@ -60,7 +64,11 @@ pub enum MissionCadence {
/// Spawn on a cron schedule (e.g., "0 */6 * * *" for every 6 hours).
Cron {
expression: String,
- timezone: Option,
+ #[serde(
+ default,
+ deserialize_with = "ironclaw_common::deserialize_option_lenient"
+ )]
+ timezone: Option,
},
/// Spawn in response to a channel message matching a regex pattern.
/// `channel`, when set, restricts firing to messages from a specific
@@ -264,3 +272,394 @@ impl Mission {
)
}
}
+
+/// Normalize a cron expression to the 7-field format expected by the `cron` crate.
+///
+/// Field formats accepted:
+/// - **5-field** (standard Vixie cron): `min hr dom mon dow` — prepend `0`
+/// (seconds) and append `*` (year).
+/// - **6-field**: assumed to be `sec min hr dom mon dow` (the `cron` crate's
+/// native format minus year) and append `*` (year). **Note:** this is *not*
+/// the Quartz `min hr dom mon dow year` interpretation. A user passing
+/// `"0 9 * * * 2027"` intending "at 09:00 every day in 2027" will instead
+/// get "at second 0 of minute 9 of every hour, every day, every year". Use
+/// the explicit 7-field form `0 0 9 * * * 2027` to disambiguate.
+/// - **7-field**: `sec min hr dom mon dow year` — passed through unchanged.
+///
+/// Returns an error for any other field count rather than passing the input
+/// through to `cron::Schedule::from_str`, which would surface a confusing
+/// low-level parse error.
+fn normalize_cron_expression(expression: &str) -> Result {
+ let trimmed = expression.trim();
+ let fields: Vec<&str> = trimmed.split_whitespace().collect();
+ match fields.len() {
+ 5 => Ok(format!("0 {} *", fields.join(" "))),
+ 6 => {
+ // Disambiguate the Quartz-style 6-field form. A user (or LLM)
+ // typing `"0 9 * * * 2027"` almost certainly means
+ // "at 09:00 every day in 2027" (Quartz: `min hr dom mon dow year`),
+ // not "at second 0 of minute 9, every hour, every day, dow=2027".
+ // The cron crate would treat the year-shaped final field as a
+ // (nonsensical) day-of-week and silently produce a wrong schedule.
+ // Reject early with a message that points at the explicit
+ // 7-field form so the caller can fix it instead of debugging a
+ // schedule that never fires.
+ if let Some(last) = fields.last()
+ && is_year_field(last)
+ {
+ return Err(EngineError::InvalidCadence {
+ reason: format!(
+ "ambiguous 6-field cron expression '{expression}': the trailing '{last}' \
+ looks like a year. The 6-field form is `sec min hr dom mon dow`, NOT the \
+ Quartz `min hr dom mon dow year`. Use the explicit 7-field form \
+ `0 {} {} {} {} {} {last}` to mean 'at the given time in {last}'.",
+ fields[0], fields[1], fields[2], fields[3], fields[4]
+ ),
+ });
+ }
+ Ok(format!("{} *", fields.join(" ")))
+ }
+ 7 => Ok(trimmed.to_string()),
+ n => Err(EngineError::InvalidCadence {
+ reason: format!(
+ "invalid cron expression '{expression}': expected 5, 6, or 7 fields, got {n}"
+ ),
+ }),
+ }
+}
+
+/// True if `field` is a literal 4-digit year in the plausible cron range.
+///
+/// Used to detect the Quartz-style `min hr dom mon dow year` mistake in
+/// 6-field input. Range chosen to cover the cron crate's accepted year span
+/// without firing on field values that happen to be 4 digits but mean
+/// something else (none of the standard cron field ranges produce 4-digit
+/// literals).
+fn is_year_field(field: &str) -> bool {
+ field.len() == 4
+ && field.bytes().all(|b| b.is_ascii_digit())
+ && field
+ .parse::()
+ .is_ok_and(|y| (1970..=2099).contains(&y))
+}
+
+/// Parse a cron expression and compute the next fire time from now.
+///
+/// Accepts standard 5-field, 6-field, or 7-field cron expressions (auto-normalized).
+/// When a [`ValidTimezone`] is provided, the schedule is evaluated in that
+/// timezone and the result is converted back to UTC. Otherwise UTC is used.
+///
+/// Cron parse failures return [`EngineError::InvalidCadence`] (validation, not
+/// storage), so callers can map them to user-facing errors.
+pub fn next_cron_fire(
+ expression: &str,
+ timezone: Option<&ValidTimezone>,
+) -> Result>, EngineError> {
+ let normalized = normalize_cron_expression(expression)?;
+ let schedule =
+ cron::Schedule::from_str(&normalized).map_err(|e| EngineError::InvalidCadence {
+ reason: format!("invalid cron expression '{expression}': {e}"),
+ })?;
+ if let Some(vtz) = timezone {
+ Ok(schedule
+ .upcoming(vtz.tz())
+ .next()
+ .map(|dt| dt.with_timezone(&Utc)))
+ } else {
+ Ok(schedule.upcoming(Utc).next())
+ }
+}
+
+/// Like [`next_cron_fire`], but treats `Ok(None)` as a validation error.
+///
+/// `next_cron_fire` returns `Ok(None)` for cron expressions that are
+/// syntactically valid but will never fire again (e.g. `0 0 9 * * * 2020` —
+/// year-locked to a year that's already passed). At lifecycle entry points
+/// (`create_mission`, cadence updates, `resume_mission`) this is the same
+/// failure mode as the original #1944 bug: an Active mission with
+/// `next_fire_at = None` that the ticker can never pick up. Surface it as
+/// `InvalidCadence` so callers fail fast and the operator gets a clear error.
+///
+/// `fire_mission` and `bootstrap_project` intentionally tolerate `Ok(None)`
+/// (logged) and should keep using `next_cron_fire` directly — the thread is
+/// already running or the data is already persisted, and aborting would do
+/// more harm than logging.
+pub fn next_cron_fire_required(
+ expression: &str,
+ timezone: Option<&ValidTimezone>,
+) -> Result, EngineError> {
+ next_cron_fire(expression, timezone)?.ok_or_else(|| EngineError::InvalidCadence {
+ reason: format!(
+ "cron expression '{expression}' has no upcoming fire time (year-locked or otherwise unschedulable)"
+ ),
+ })
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use chrono::{Datelike, Timelike};
+
+ #[test]
+ fn rejects_four_field_cron() {
+ // Four-field input is not a recognized cron format. Surface a clear
+ // error rather than passing through to a low-level parse failure.
+ let err = next_cron_fire("* * * *", None).unwrap_err();
+ let msg = err.to_string();
+ assert!(msg.contains("expected 5, 6, or 7 fields"), "got: {msg}");
+ }
+
+ #[test]
+ fn accepts_five_field_cron() {
+ let next = next_cron_fire("0 9 * * *", None).unwrap();
+ assert!(next.is_some(), "5-field cron should produce a fire time");
+ }
+
+ #[test]
+ fn next_cron_fire_respects_timezone() {
+ // "0 9 * * *" in America/New_York should produce a UTC instant whose
+ // wall-clock time in NY is 09:00 on some date — and the resulting UTC
+ // hour should differ from a UTC-evaluated schedule (since NY is offset
+ // from UTC year-round).
+ let tz = ValidTimezone::parse("America/New_York").unwrap();
+ let in_ny = next_cron_fire("0 9 * * *", Some(&tz))
+ .unwrap()
+ .expect("schedule should produce a fire time");
+ let in_utc = next_cron_fire("0 9 * * *", None)
+ .unwrap()
+ .expect("schedule should produce a fire time");
+
+ // NY 09:00 in UTC is either 13:00 (EDT) or 14:00 (EST). UTC 09:00 is 09:00.
+ let ny_utc_hour = in_ny.hour();
+ assert!(
+ ny_utc_hour == 13 || ny_utc_hour == 14,
+ "NY 09:00 should map to UTC 13 or 14, got {ny_utc_hour}"
+ );
+ assert_eq!(in_utc.hour(), 9, "UTC schedule should fire at hour 9");
+ assert_ne!(
+ in_ny.hour(),
+ in_utc.hour(),
+ "tz-aware and tz-naive schedules should differ"
+ );
+
+ // Sanity: result is a real future date, not the epoch. Compare
+ // against `Utc::now()` so the assertion stays stable across calendar
+ // years rather than being pinned to a hard-coded threshold.
+ assert!(in_ny > Utc::now(), "next cron fire must be in the future");
+ }
+
+ #[test]
+ fn normalize_six_field_cron() {
+ // 6-field (with seconds) should be accepted.
+ let next = next_cron_fire("0 0 9 * * *", None).unwrap();
+ assert!(next.is_some());
+ }
+
+ #[test]
+ fn six_field_cron_is_sec_min_hr_dom_mon_dow_not_quartz_with_year() {
+ // Pin the 6-field interpretation: `sec min hr dom mon dow`, NOT the
+ // Quartz-style `min hr dom mon dow year`. A 6-field input gets `*`
+ // appended for the year position. This test exists so a future change
+ // doesn't silently flip the interpretation and break existing
+ // missions.
+ let normalized = normalize_cron_expression("0 0 9 * * *").unwrap();
+ assert_eq!(
+ normalized, "0 0 9 * * * *",
+ "6-field input must be treated as `sec min hr dom mon dow` and appended with `*` (year)"
+ );
+
+ // Sanity: the resulting schedule fires at 09:00:00 wall-clock daily.
+ let next = next_cron_fire("0 0 9 * * *", None).unwrap().unwrap();
+ assert_eq!(next.hour(), 9);
+ assert_eq!(next.minute(), 0);
+ assert_eq!(next.second(), 0);
+ }
+
+ #[test]
+ fn normalize_seven_field_cron() {
+ // 7-field (sec min hr dom mon dow year) should pass through.
+ let next = next_cron_fire("0 0 9 * * * 2027", None).unwrap();
+ assert!(next.is_some());
+ }
+
+ #[test]
+ fn six_field_cron_with_year_shaped_last_field_is_rejected() {
+ // A user (or LLM) typing the Quartz-style `min hr dom mon dow year`
+ // form gets a clear error pointing at the explicit 7-field form,
+ // rather than a silently misparsed schedule. The 6-field form is
+ // `sec min hr dom mon dow`, so `2027` would otherwise be interpreted
+ // as a (nonsensical) day-of-week.
+ let err = next_cron_fire("0 9 * * * 2027", None).unwrap_err();
+ let msg = err.to_string();
+ assert!(
+ matches!(err, EngineError::InvalidCadence { .. }),
+ "expected InvalidCadence, got: {err:?}"
+ );
+ assert!(
+ msg.contains("looks like a year") && msg.contains("0 0 9 * * * 2027"),
+ "error should explain Quartz ambiguity and suggest 7-field form, got: {msg}"
+ );
+
+ // Cover all year boundaries.
+ for year in ["1970", "1999", "2000", "2026", "2099"] {
+ let expr = format!("0 0 * * * {year}");
+ assert!(
+ matches!(
+ next_cron_fire(&expr, None),
+ Err(EngineError::InvalidCadence { .. })
+ ),
+ "year {year} should be rejected as Quartz-style ambiguity"
+ );
+ }
+
+ // Out-of-range 4-digit values are NOT treated as years and fall
+ // through to the regular 6-field interpretation (which the cron
+ // crate may then reject for its own reasons).
+ let normalized = normalize_cron_expression("0 0 9 * * 1969");
+ assert!(
+ normalized.is_ok(),
+ "1969 (out of year range) should not trigger the Quartz heuristic"
+ );
+
+ // 5-field cron with a literal day-of-week numeric value must still
+ // work — the year heuristic only applies to 6-field input.
+ assert!(next_cron_fire("0 9 * * 3", None).unwrap().is_some());
+ }
+
+ #[test]
+ fn invalid_cron_returns_invalid_cadence_error() {
+ // Cron parse errors are validation errors, not store errors.
+ let err = next_cron_fire("not a cron", None).unwrap_err();
+ assert!(
+ matches!(err, EngineError::InvalidCadence { .. }),
+ "expected InvalidCadence, got: {err:?}"
+ );
+
+ let err = next_cron_fire("nope nope nope nope nope", None).unwrap_err();
+ assert!(matches!(err, EngineError::InvalidCadence { .. }));
+ }
+
+ // ── DST tests (#1944) ─────────────────────────────────────
+ //
+ // The whole point of carrying user_timezone through the engine is so that
+ // cron schedules respect DST. These tests pin the cron crate's behavior on
+ // the two tricky transitions in `America/New_York`:
+ //
+ // * Spring-forward: 2027-03-14 02:00 jumps to 03:00. Local times in
+ // [02:00, 03:00) do not exist on that day.
+ // * Fall-back: 2027-11-07 02:00 jumps back to 01:00. Local times in
+ // [01:00, 02:00) occur twice (once EDT, once EST).
+ //
+ // We don't test specific calendar dates (those would rot); instead we use
+ // explicit reference instants via the `cron` crate's `after()` method to
+ // assert behavior in a year-independent way.
+
+ use chrono::TimeZone;
+
+ fn schedule_after(
+ expression: &str,
+ tz: &ValidTimezone,
+ after_utc: DateTime,
+ ) -> DateTime {
+ let normalized = normalize_cron_expression(expression).unwrap(); // safety: test helper
+ let schedule = cron::Schedule::from_str(&normalized).unwrap(); // safety: test helper
+ let after_local = after_utc.with_timezone(&tz.tz());
+ schedule
+ .after(&after_local)
+ .next()
+ .expect("schedule should produce a fire time") // safety: test helper
+ .with_timezone(&Utc)
+ }
+
+ #[test]
+ fn dst_spring_forward_skips_missing_local_hour() {
+ // 2027-03-14 in America/New_York: clocks jump 02:00 -> 03:00 EDT.
+ // A cron at "30 2 * * *" requests a wall-clock time that does not
+ // exist on that day. The cron crate skips that occurrence and fires
+ // on the next valid day at 02:30 (which is then EDT, UTC-4).
+ let tz = ValidTimezone::parse("America/New_York").unwrap();
+
+ // Reference: 2027-03-13 00:00 UTC = 2027-03-12 19:00 EST, well
+ // before the spring-forward day. We just need a stable anchor.
+ let after = Utc.with_ymd_and_hms(2027, 3, 13, 0, 0, 0).unwrap();
+ let fire = schedule_after("30 2 * * *", &tz, after);
+
+ // The first fire on 2027-03-13 is 02:30 EST = 07:30 UTC. The next
+ // fire would be 2027-03-14 02:30 — but that doesn't exist on DST
+ // day, so the schedule skips to 2027-03-15 02:30 EDT = 06:30 UTC.
+ // Whichever the cron crate picks, it must NOT land in the missing
+ // local interval [02:00, 03:00) on 2027-03-14.
+ let fire_local = fire.with_timezone(&tz.tz());
+ if fire_local.year() == 2027 && fire_local.month() == 3 && fire_local.day() == 14 {
+ // If it lands on DST day, the wall-clock hour must be >= 3 (EDT).
+ assert!(
+ fire_local.hour() >= 3,
+ "fire on DST day must not be in skipped [02:00, 03:00) window, got {fire_local}"
+ );
+ }
+ // Sanity: the result is a real future instant.
+ assert!(fire > after);
+ }
+
+ #[test]
+ fn dst_fall_back_picks_one_of_overlapping_hours() {
+ // 2027-11-07 in America/New_York: clocks jump 02:00 EDT -> 01:00 EST.
+ // Local times in [01:00, 02:00) occur twice. A cron at "30 1 * * *"
+ // could fire at 01:30 EDT (05:30 UTC) or 01:30 EST (06:30 UTC).
+ // The cron crate picks one consistently — we just assert it picks
+ // exactly one and that the result is correct in UTC.
+ let tz = ValidTimezone::parse("America/New_York").unwrap();
+ let after = Utc.with_ymd_and_hms(2027, 11, 6, 12, 0, 0).unwrap();
+ let fire = schedule_after("30 1 * * *", &tz, after);
+
+ let fire_local = fire.with_timezone(&tz.tz());
+ // Whatever date the cron crate lands on, the local time must be 01:30.
+ assert_eq!(
+ fire_local.hour(),
+ 1,
+ "expected hour 1 local, got {fire_local}"
+ );
+ assert_eq!(
+ fire_local.minute(),
+ 30,
+ "expected minute 30 local, got {fire_local}"
+ );
+
+ // And the UTC instant must be exactly one of the two valid 01:30 NY
+ // instants on the fall-back day, OR a 01:30 NY on a neighbouring day.
+ // Either way, converting back must round-trip to the same wall clock.
+ let round_trip = fire.with_timezone(&tz.tz());
+ assert_eq!(round_trip, fire_local);
+ }
+
+ #[test]
+ fn dst_aware_schedule_advances_correctly_across_transition() {
+ // Across a DST transition the absolute UTC interval between two
+ // consecutive 09:00 local fires shifts by an hour. This is the
+ // "load-bearing tz" property the PR exists to enable.
+ let tz = ValidTimezone::parse("America/New_York").unwrap();
+ // Pick an anchor in EST (winter, before spring-forward).
+ let anchor = Utc.with_ymd_and_hms(2027, 3, 1, 0, 0, 0).unwrap();
+ let normalized = normalize_cron_expression("0 9 * * *").unwrap();
+ let schedule = cron::Schedule::from_str(&normalized).unwrap();
+ let anchor_local = anchor.with_timezone(&tz.tz());
+
+ // Take 30 consecutive fires — long enough to cross spring-forward.
+ let fires: Vec<_> = schedule.after(&anchor_local).take(30).collect();
+ assert_eq!(fires.len(), 30);
+
+ // All fires must be at 09:00 local wall clock, regardless of DST.
+ for f in &fires {
+ assert_eq!(f.hour(), 9, "every fire must be 09:00 local, got {f}");
+ }
+
+ // The UTC hour shifts when crossing DST: 09:00 EST = 14:00 UTC,
+ // 09:00 EDT = 13:00 UTC. Both must appear across the 30-day window.
+ let utc_hours: std::collections::BTreeSet =
+ fires.iter().map(|f| f.with_timezone(&Utc).hour()).collect();
+ assert!(
+ utc_hours.contains(&13) && utc_hours.contains(&14),
+ "30-day window straddling spring-forward should contain both 13:00 and 14:00 UTC fires; got {utc_hours:?}"
+ );
+ }
+}
diff --git a/crates/ironclaw_gateway/Cargo.toml b/crates/ironclaw_gateway/Cargo.toml
new file mode 100644
index 00000000000..0eaa87881e9
--- /dev/null
+++ b/crates/ironclaw_gateway/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "ironclaw_gateway"
+version = "0.1.0"
+edition = "2024"
+rust-version = "1.92"
+description = "Gateway frontend assets, layout configuration, and widget extension system for IronClaw"
+license = "MIT OR Apache-2.0"
+
+[package.metadata.dist]
+dist = false
+
+[dependencies]
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+thiserror = "2"
+tracing = "0.1"
diff --git a/crates/ironclaw_gateway/src/assets.rs b/crates/ironclaw_gateway/src/assets.rs
new file mode 100644
index 00000000000..3faca18eea8
--- /dev/null
+++ b/crates/ironclaw_gateway/src/assets.rs
@@ -0,0 +1,40 @@
+//! Embedded static assets for the IronClaw web gateway.
+//!
+//! All frontend files are compiled into the binary via `include_str!()` /
+//! `include_bytes!()`. The web gateway serves these as the default baseline;
+//! workspace-stored customizations (layout config, widgets, CSS overrides)
+//! are layered on top at runtime.
+
+// ==================== Core Files ====================
+
+/// Main HTML page (SPA shell).
+pub const INDEX_HTML: &str = include_str!("../static/index.html");
+
+/// Main application JavaScript.
+pub const APP_JS: &str = include_str!("../static/app.js");
+
+/// Base stylesheet.
+pub const STYLE_CSS: &str = include_str!("../static/style.css");
+
+/// Theme initialization script (runs synchronously in `` to prevent FOUC).
+pub const THEME_INIT_JS: &str = include_str!("../static/theme-init.js");
+
+/// Favicon.
+pub const FAVICON_ICO: &[u8] = include_bytes!("../static/favicon.ico");
+
+// ==================== Internationalization ====================
+
+/// i18n core library.
+pub const I18N_INDEX_JS: &str = include_str!("../static/i18n/index.js");
+
+/// English translations.
+pub const I18N_EN_JS: &str = include_str!("../static/i18n/en.js");
+
+/// Chinese (Simplified) translations.
+pub const I18N_ZH_CN_JS: &str = include_str!("../static/i18n/zh-CN.js");
+
+/// Korean translations.
+pub const I18N_KO_JS: &str = include_str!("../static/i18n/ko.js");
+
+/// i18n integration with the app.
+pub const I18N_APP_JS: &str = include_str!("../static/i18n-app.js");
diff --git a/crates/ironclaw_gateway/src/bundle.rs b/crates/ironclaw_gateway/src/bundle.rs
new file mode 100644
index 00000000000..0b615df6ad4
--- /dev/null
+++ b/crates/ironclaw_gateway/src/bundle.rs
@@ -0,0 +1,757 @@
+//! Frontend bundle assembly.
+//!
+//! Combines the embedded base HTML with workspace customizations (layout
+//! config, widgets, CSS overrides) into the final served page.
+
+use crate::layout::LayoutConfig;
+use crate::widget::{WidgetManifest, scope_css};
+
+/// Escape HTML special characters to prevent XSS in text content.
+fn escape_html(s: &str) -> String {
+ s.replace('&', "&")
+ .replace('<', "<")
+ .replace('>', ">")
+}
+
+/// Escape HTML attribute value (includes quotes).
+fn escape_html_attr(s: &str) -> String {
+ s.replace('&', "&")
+ .replace('<', "<")
+ .replace('>', ">")
+ .replace('"', """)
+}
+
+/// Rewrite any occurrence of `needle` (ASCII, case-insensitive) in `s` by
+/// inserting a backslash between the leading `<` and `/`, turning `` or ``, which let a `` sequence inside a color
+ // value close the tag early and inject arbitrary HTML. Apply the same
+ // escape here so branding stays in lock-step with the other paths.
+ let css_vars = bundle.layout.branding.to_css_vars();
+ if !css_vars.is_empty() {
+ let safe_vars = escape_tag_close(&css_vars, "{}", safe_vars));
+ }
+
+ // --- Body injections ---
+
+ // Layout config as global variable. JSON strings can contain ``
+ // (serde_json does not escape `<` or `/` by default), so neutralize any
+ // ` tag.
+ //
+ // The `nonce` attribute carries the [`NONCE_PLACEHOLDER`] sentinel — the
+ // gateway swaps it for a fresh per-response nonce that matches the
+ // response's `Content-Security-Policy` header. Without the nonce the
+ // browser blocks this inline script under the gateway's CSP.
+ match serde_json::to_string(&bundle.layout) {
+ Ok(layout_json) => {
+ let safe_layout = escape_tag_close(&layout_json, "window.__IRONCLAW_LAYOUT__ = {safe_layout};"
+ ));
+ }
+ Err(e) => {
+ // `LayoutConfig` and every nested type derive `Serialize` cleanly,
+ // so this branch is unreachable on well-typed input. Surface it
+ // anyway — a silent drop here would mean the customized HTML
+ // ships without `window.__IRONCLAW_LAYOUT__`, and the IIFE in
+ // `app.js` would no-op all branding/tab/chat customizations
+ // without leaving a trace. A loud warn at the failure site is
+ // cheap insurance against a future refactor that introduces a
+ // serialization-fallible field.
+ tracing::warn!(
+ error = %e,
+ "failed to serialize LayoutConfig for window.__IRONCLAW_LAYOUT__ injection — \
+ customizations will not apply"
+ );
+ }
+ }
+
+ // Widget CSS (scoped) and JS
+ for widget in &bundle.widgets {
+ if let Some(ref css) = widget.css {
+ let scoped = scope_css(css, &widget.manifest.id);
+ if !scoped.trim().is_empty() {
+ // Neutralize any `` would otherwise break out of the tag.
+ //
+ // No nonce needed: the gateway's CSP allows `'unsafe-inline'`
+ // for `style-src`. Scripts are the only nonce-gated tags.
+ let safe_css = escape_tag_close(&scoped, "{}",
+ escape_html_attr(&widget.manifest.id),
+ safe_css
+ ));
+ }
+ }
+
+ // Widget JS inlined (avoids auth issues with ` to prevent tag breakout (XSS) and
+ // stamp the CSP nonce placeholder so the gateway can authorize this
+ // script under its `script-src 'nonce-…'` policy.
+ let safe_js = escape_tag_close(&widget.js, "\n{}\n",
+ NONCE_PLACEHOLDER,
+ escape_html_attr(&widget.manifest.id),
+ safe_js
+ ));
+ }
+
+ // Custom CSS
+ if let Some(ref custom_css) = bundle.custom_css
+ && !custom_css.trim().is_empty()
+ {
+ // Same reasoning as widget CSS — neutralize `{}", safe_custom));
+ }
+
+ // --- Assemble ---
+
+ let mut result = base_html.to_string();
+
+ // Inject before
+ if !head_injections.is_empty() {
+ let head_block = head_injections.join("\n");
+ if let Some(pos) = result.rfind("") {
+ result.insert_str(pos, &format!("\n{}\n", head_block));
+ }
+ }
+
+ // Override if branding title is set (HTML-escaped to prevent XSS)
+ if let Some(ref title) = bundle.layout.branding.title
+ && let Some(start) = result.find("<title>")
+ && let Some(end) = result[start..].find("")
+ {
+ let end = start + end + "".len();
+ result.replace_range(
+ start..end,
+ &format!("{}", escape_html(title)),
+ );
+ }
+
+ // Inject before
+ if !body_injections.is_empty() {
+ let body_block = body_injections.join("\n");
+ if let Some(pos) = result.rfind("") {
+ result.insert_str(pos, &format!("\n{}\n", body_block));
+ }
+ }
+
+ result
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::layout::*;
+ use crate::widget::*;
+
+ const MINIMAL_HTML: &str =
+ "