tactus 0.38.0__tar.gz → 0.40.0__tar.gz

{tactus-0.38.0 → tactus-0.40.0}/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 <!-- version list -->
 
+## v0.40.0 (2026-02-05)
+
+### Bug Fixes
+
+- Avoid duplicate run dependency execution
+  ([`f0ead11`](https://github.com/AnthusAI/Tactus/commit/f0ead110e30a97b9c229dee5efaec7008f486269))
+
+- Normalize task kind aliases without biblicus
+  ([`62296b7`](https://github.com/AnthusAI/Tactus/commit/62296b7528540f0079c73e7f64655a6bc05c1498))
+
+
+## v0.39.0 (2026-02-05)
+
+
 ## v0.38.0 (2026-02-03)
 
 ### Bug Fixes

{tactus-0.38.0 → tactus-0.40.0}/IMPLEMENTATION.md

@@ -95,6 +95,30 @@ All checkpoints are tracked by execution position, not name. This enables:
 }
 ```
 
+---
+
+## Tasks + Dependency Planning
+
+**Status**: ✅ **Implemented (Biblicus-first dependency engine)**
+
+### Task declarations
+- **Registry model**: `tactus/core/registry.py` (`TaskDeclaration`)
+- **DSL stubs**: `tactus/core/dsl_stubs.py` (`Task`, `IncludeTasks`)
+- **Runtime registration**: `tactus/core/runtime.py` (`_register_assignment_tasks`)
+
+### Dependency planning
+- **Biblicus plan builder**: `biblicus.workflow` (`Task`, `Plan`, `build_plan_for_*`)
+- **Runtime execution**: `tactus/core/runtime.py`
+  - `_execute_run_dependencies()` before running main/script mode
+  - `_execute_retriever_index()` uses Biblicus plans + handlers
+  - `depends_on` executed before task entries
+  - `provides` maps custom tasks to dependency kinds (e.g., load)
+
+### CLI UX
+- `tactus/cli/app.py` flags:
+  - `--auto-deps` to run dependencies automatically
+  - `--no-deps` to fail fast when dependencies are missing
+
 **Status**: ✅ **Fully Implemented** (Local execution context)
 
 **Note**: Lambda Durable Execution Context mentioned in spec is **not implemented**. Only local context exists.

{tactus-0.38.0 → tactus-0.40.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tactus
-Version: 0.38.0
+Version: 0.40.0
 Summary: Tactus: Lua-based DSL for agentic workflows
 Project-URL: Homepage, https://github.com/AnthusAI/Tactus
 Project-URL: Documentation, https://github.com/AnthusAI/Tactus/tree/main/docs

{tactus-0.38.0 → tactus-0.40.0}/SPECIFICATION.md

@@ -101,6 +101,45 @@ Feature: Task Processing
 
 ---
 
+## Tasks and Dependency Planning
+
+Tasks provide statically discoverable entrypoints that complement Procedures and script mode.
+
+### Task syntax
+```lua
+Task "fetch" {
+  provides = { kind = "load", corpus = "miami_afd" },
+  entry = function()
+    return FetchNoaaAfd({ wfo = "MFL", max_items = 5 })
+  end
+}
+
+run = Task {
+  depends_on = {"index"},
+  entry = function()
+    return Miami("Summarize the recent Miami AFD.")
+  end
+}
+```
+
+### Dependency behavior
+- Built-in task kinds: `load`, `ingest`, `extract`, `index`, `query`.
+- Aliases normalize to canonical kinds:
+  - `fetch`/`sync → load`
+  - `build → index`
+  - `run → query`
+- `index` depends on `extract`; `extract` depends on `load` when the corpus is empty.
+- Task `provides` declarations allow custom tasks to satisfy dependency kinds.
+
+### CLI integration
+- `tactus file.tac index` runs all retrievers that support indexing.
+- `tactus file.tac index:retriever_name` runs a single retriever.
+- `tactus file.tac run` prompts before running dependency tasks unless:
+  - `--auto-deps` is set (run dependencies automatically)
+  - `--no-deps` is set (fail fast if dependencies are missing)
+
+---
+
 ## Input
 
 Input schema defines what the procedure accepts. Validated before execution.

{tactus-0.38.0 → tactus-0.40.0}/docs/TASKS_RETRIEVAL_OVERHAUL_BRIEF.md

@@ -30,6 +30,11 @@ This brief is the source of truth for implementation decisions.
 - Evidence
 - Configuration
 - Pipeline
+- Load
+- Ingest
+- Extract
+- Index
+- Query
 
 Removed from user-facing vocabulary:
 - backend
@@ -77,6 +82,7 @@ miami_search = TfVector.Retriever {
 ### Task (explicit)
 ```lua
 Task "fetch" {
+  provides = { kind = "load", corpus = "miami_afd" },
   Task "NOAA" {
     entry = function()
       return FetchNoaaAfd { wfo = "MFL", max_items = 5, corpus = miami_afd }
@@ -88,6 +94,7 @@ Task "fetch" {
 ### Task (assignment sugar)
 ```lua
 fetch = Task {
+  provides = { kind = "load", corpus = "miami_afd" },
   NOAA = Task {
     entry = function()
       return FetchNoaaAfd { wfo = "MFL", max_items = 5, corpus = miami_afd }
@@ -170,6 +177,26 @@ The script-mode transform must treat these as declarations (not executable code)
   - `tactus file.tac index:retriever_name` runs only that retriever.
 - If a user-defined `Task "index"` exists, it overrides auto-aggregation.
 
+## Biblicus-First Task Dependencies (Load → Extract → Index)
+- Biblicus owns dependency planning/execution via `Task` + `Plan` (no TaskSpec).
+- Built-in dependency rules:
+  - `query → index` (if no compatible retrieval snapshot exists)
+  - `index → extract` (always)
+  - `extract → load` (only if corpus empty and a load handler exists)
+  - `ingest` has no dependencies
+- Default extraction pipeline is pass-through text if none configured.
+- Task kind aliases normalize to canonical kinds:
+  - `fetch`/`sync → load`
+  - `build → index`
+  - `run → query`
+
+### Task dependency hooks (Tactus)
+Tasks can plug into Biblicus dependency planning via:
+- `depends_on = {"load", "extract"}`
+- `provides = { kind = "load", corpus = "miami_afd" }`
+
+`provides` lets custom tasks satisfy built-in dependency kinds.
+
 ## Snapshot Semantics
 - Retrieval build artifacts are called **snapshots** (not runs/indexes).
 - Use `snapshot`, `snapshot_id`, `snapshot_manifest`, `snapshot_artifacts`.
@@ -192,6 +219,12 @@ Retriever auto-tasks:
 - `tactus file.tac index:retriever_a` runs only that retriever.
 - User-defined `Task "index"` overrides auto aggregation.
 
+Dependency planning:
+- `tactus file.tac run` prompts when dependencies (load/extract/index) are required.
+- `tactus file.tac run --auto-deps` executes dependency tasks without prompting.
+- `tactus file.tac run --no-deps` fails fast if dependencies are missing.
+- `provides` tasks can satisfy `load` dependencies (e.g. fetch task).
+
 Extraction:
 - `pipeline.extract` runs automatically on ingest.
 - No explicit extraction task required.

{tactus-0.38.0 → tactus-0.40.0}/examples/90-noaa-brief.tac

@@ -6,47 +6,13 @@
 local FilesystemCorpus = require("tactus.corpora.filesystem")
 local TfVector = require("tactus.retrievers.tf_vector")
 
-python = Tool {
-  use = "cli.python3",
-  description = "Run python3 scripts"
+FetchNoaaAfd = Tool {
+  use = "plugin.noaa.fetch_noaa_afd",
+  description = "Fetch NOAA AFD fixtures and import into Biblicus"
 }
 
-FetchNoaaAfd = function(params)
-  Log.info("FetchNoaaAfd: fetching NOAA AFD fixtures")
-  python({
-    args = {
-      "scripts/fetch_noaa_afd_corpus.py",
-      "--wfo", params.wfo,
-      "--max-items", tostring(params.max_items),
-      "--output", "tests/fixtures/noaa_afd",
-    }
-  })
-  Log.info("FetchNoaaAfd: building Biblicus corpus + tf-vector index")
-  python({
-    args = {
-      "scripts/prepare_noaa_afd_biblicus_corpus.py",
-      "--retriever", "tf-vector",
-      "--wfo", params.wfo,
-      "--force",
-    }
-  })
-  return {
-    status = "ok",
-    wfo = params.wfo,
-    max_items = params.max_items,
-  }
-end
-
 miami_afd = FilesystemCorpus.Corpus {
-  root = "tests/fixtures/noaa_afd_corpus/MFL",
-  configuration = {
-    pipeline = {
-      -- Extraction runs automatically on ingest.
-      extract = {
-        -- Placeholder for composed extraction steps.
-      }
-    }
-  }
+  root = "tests/fixtures/noaa_afd_corpus/MFL"
 }
 
 miami_search = TfVector.Retriever {
@@ -77,12 +43,12 @@ Miami = Agent {
   context = miami_context
 }
 
-fetch = Task {
+Task "fetch" {
+  provides = { kind = "load", corpus = "miami_afd" },
   entry = function()
     return FetchNoaaAfd({
       wfo = "MFL",
       max_items = 5,
-      corpus = miami_afd
     })
   end
 }

tactus-0.40.0/features/90_task_dependency_planning.feature

@@ -0,0 +1,41 @@
+Feature: Task dependency planning
+  As a workflow developer
+  I want load/extract/index dependencies to be planned and enforced
+  So that retrievers are ready before run executes
+
+  Scenario: Auto-deps builds extraction and index snapshots
+    Given a NOAA corpus fixture copy
+    And a task workflow that uses the copied corpus
+    When I run "tactus run --no-sandbox --auto-deps" on the file
+    Then the command should succeed
+    And an extraction snapshot should exist
+    And a retrieval snapshot should exist
+
+  Scenario: Prompt accepts dependency execution
+    Given a NOAA corpus fixture copy
+    And a task workflow that uses the copied corpus
+    And I provide CLI input "y"
+    When I run "tactus run --no-sandbox" on the file
+    Then the command should succeed
+    And an extraction snapshot should exist
+
+  Scenario: No-deps fails fast when dependencies are missing
+    Given a NOAA corpus fixture copy
+    And a task workflow that uses the copied corpus
+    When I run "tactus run --no-sandbox --no-deps" on the file
+    Then the command should fail
+    And the output should show "Dependencies missing"
+
+  Scenario: Index task fans out across multiple retrievers
+    Given a NOAA corpus fixture copy
+    And a task workflow with two retrievers
+    When I run "tactus run --no-sandbox --auto-deps index" on the file
+    Then the command should succeed
+    And at least 2 retrieval snapshots should exist
+
+  Scenario: Load handler runs for empty corpus
+    Given an empty corpus workspace
+    And a task workflow with a load provider
+    When I run "tactus run --no-sandbox --auto-deps" on the file
+    Then the command should succeed
+    And the load marker should exist

{tactus-0.38.0 → tactus-0.40.0}/features/steps/cli_run_steps.py

@@ -32,7 +32,13 @@ def step_run_tactus_on_file(context, args):
         [sys.executable, "-m", "tactus.cli.app", *cli_args],
         capture_output=True,
         text=True,
+        input=getattr(context, "cli_input", None),
     )
     context.cli_returncode = result.returncode
     context.cli_stdout = result.stdout
     context.cli_stderr = result.stderr
+
+
+@when('I run "tactus run" on the file')
+def step_run_tactus_on_file_no_args(context):
+    step_run_tactus_on_file(context, "")

tactus-0.40.0/features/steps/task_dependency_steps.py

@@ -0,0 +1,202 @@
+"""
+Steps for task dependency planning scenarios.
+"""
+
+import shutil
+import tempfile
+from pathlib import Path
+
+from behave import given, then
+
+
+@given("a NOAA corpus fixture copy")
+def step_copy_noaa_corpus(context):
+    fixture_root = Path("tests/fixtures/noaa_afd_corpus/MFL").resolve()
+    if not fixture_root.exists():
+        raise AssertionError(f"Fixture corpus not found: {fixture_root}")
+
+    temp_dir = tempfile.mkdtemp(prefix="tactus_noaa_corpus_")
+    corpus_root = Path(temp_dir) / "MFL"
+    shutil.copytree(fixture_root, corpus_root, dirs_exist_ok=True)
+    context.corpus_root = corpus_root
+
+
+@given("an empty corpus workspace")
+def step_empty_corpus_workspace(context):
+    temp_dir = tempfile.mkdtemp(prefix="tactus_empty_corpus_")
+    corpus_root = Path(temp_dir) / "MFL"
+    corpus_root.mkdir(parents=True, exist_ok=True)
+    context.corpus_root = corpus_root
+
+
+@given("a task workflow that uses the copied corpus")
+def step_write_dependency_workflow(context):
+    if not hasattr(context, "corpus_root"):
+        raise AssertionError("Corpus root not set for dependency workflow")
+
+    workflow_source = f"""local FilesystemCorpus = require("tactus.corpora.filesystem")
+local TfVector = require("tactus.retrievers.tf_vector")
+
+miami_afd = FilesystemCorpus.Corpus {{
+  root = "{context.corpus_root.as_posix()}"
+}}
+
+miami_search = TfVector.Retriever {{
+  corpus = miami_afd,
+  configuration = {{
+    pipeline = {{
+      query = {{
+        limit = 1,
+        maximum_total_characters = 2000
+      }}
+    }}
+  }}
+}}
+
+Task "run" {{
+  entry = function()
+    return {{ status = "ok" }}
+  end
+}}
+"""
+
+    temp_file = tempfile.NamedTemporaryFile(mode="w", suffix=".tac", delete=False)
+    temp_file.write(workflow_source)
+    temp_file.close()
+    context.lua_file = Path(temp_file.name)
+
+
+@given("a task workflow with two retrievers")
+def step_write_multi_retriever_workflow(context):
+    if not hasattr(context, "corpus_root"):
+        raise AssertionError("Corpus root not set for dependency workflow")
+
+    workflow_source = f"""local FilesystemCorpus = require("tactus.corpora.filesystem")
+local TfVector = require("tactus.retrievers.tf_vector")
+
+miami_afd = FilesystemCorpus.Corpus {{
+  root = "{context.corpus_root.as_posix()}"
+}}
+
+miami_search = TfVector.Retriever {{
+  corpus = miami_afd,
+  configuration = {{
+    pipeline = {{
+      query = {{
+        limit = 1,
+        maximum_total_characters = 2000
+      }}
+    }}
+  }}
+}}
+
+miami_search_two = TfVector.Retriever {{
+  corpus = miami_afd,
+  configuration = {{
+    pipeline = {{
+      query = {{
+        limit = 2,
+        maximum_total_characters = 2000
+      }}
+    }}
+  }}
+}}
+"""
+
+    temp_file = tempfile.NamedTemporaryFile(mode="w", suffix=".tac", delete=False)
+    temp_file.write(workflow_source)
+    temp_file.close()
+    context.lua_file = Path(temp_file.name)
+
+
+@given("a task workflow with a load provider")
+def step_write_load_provider_workflow(context):
+    if not hasattr(context, "corpus_root"):
+        raise AssertionError("Corpus root not set for dependency workflow")
+
+    marker_path = (Path(context.corpus_root) / "loaded.txt").as_posix()
+    workflow_source = f"""local FilesystemCorpus = require("tactus.corpora.filesystem")
+local TfVector = require("tactus.retrievers.tf_vector")
+local file = require("tactus.io.file")
+
+miami_afd = FilesystemCorpus.Corpus {{
+  root = "{context.corpus_root.as_posix()}"
+}}
+
+miami_search = TfVector.Retriever {{
+  corpus = miami_afd,
+  configuration = {{
+    pipeline = {{
+      query = {{
+        limit = 1,
+        maximum_total_characters = 2000
+      }}
+    }}
+  }}
+}}
+
+Task "fetch" {{
+  provides = {{ kind = "load", corpus = "miami_afd" }},
+  entry = function()
+    file.write("{marker_path}", "loaded")
+    return {{ status = "loaded" }}
+  end
+}}
+
+Task "run" {{
+  entry = function()
+    return {{ status = "ok" }}
+  end
+}}
+"""
+
+    temp_file = tempfile.NamedTemporaryFile(mode="w", suffix=".tac", delete=False)
+    temp_file.write(workflow_source)
+    temp_file.close()
+    context.lua_file = Path(temp_file.name)
+
+
+@given('I provide CLI input "{value}"')
+def step_set_cli_input(context, value):
+    context.cli_input = f"{value}\n"
+
+
+@then("an extraction snapshot should exist")
+def step_assert_extraction_snapshot(context):
+    corpus_root = Path(context.corpus_root)
+    snapshots_root = corpus_root / ".biblicus" / "snapshots" / "extraction"
+    if not snapshots_root.exists():
+        raise AssertionError("Extraction snapshots directory missing")
+
+    manifests = list(snapshots_root.glob("**/manifest.json"))
+    assert manifests, "No extraction snapshot manifests found"
+
+
+@then("a retrieval snapshot should exist")
+def step_assert_retrieval_snapshot(context):
+    corpus_root = Path(context.corpus_root)
+    snapshots_root = corpus_root / ".biblicus" / "snapshots"
+    if not snapshots_root.exists():
+        raise AssertionError("Snapshots directory missing")
+
+    snapshot_files = [path for path in snapshots_root.glob("*.json") if path.is_file()]
+    assert snapshot_files, "No retrieval snapshot manifests found"
+
+
+@then("at least {count:d} retrieval snapshots should exist")
+def step_assert_retrieval_snapshot_count(context, count):
+    corpus_root = Path(context.corpus_root)
+    snapshots_root = corpus_root / ".biblicus" / "snapshots"
+    if not snapshots_root.exists():
+        raise AssertionError("Snapshots directory missing")
+
+    snapshot_files = [path for path in snapshots_root.glob("*.json") if path.is_file()]
+    assert (
+        len(snapshot_files) >= count
+    ), f"Expected at least {count} retrieval snapshots, found {len(snapshot_files)}"
+
+
+@then("the load marker should exist")
+def step_assert_load_marker(context):
+    marker_path = Path(context.corpus_root) / "loaded.txt"
+    assert marker_path.exists(), f"Load marker not found: {marker_path}"

{tactus-0.38.0 → tactus-0.40.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "tactus"
-version = "0.38.0"
+version = "0.40.0"
 description = "Tactus: Lua-based DSL for agentic workflows"
 readme = "README.md"
 requires-python = ">=3.9"

{tactus-0.38.0 → tactus-0.40.0}/scripts/prepare_noaa_afd_biblicus_corpus.py

@@ -52,6 +52,11 @@ def main() -> None:
         help="Snippet length budget for evidence text",
     )
     parser.add_argument("--force", action="store_true", help="Recreate the corpus directory")
+    parser.add_argument(
+        "--no-index",
+        action="store_true",
+        help="Only import items into the corpus (skip retriever snapshot build)",
+    )
     args = parser.parse_args()
 
     source_dir = _resolve_source_dir(args.source, args.wfo)
@@ -74,6 +79,11 @@ def main() -> None:
     for path in (corpus_dir / "raw").rglob("*.biblicus.yml.biblicus.yml"):
         path.unlink(missing_ok=True)
 
+    if args.no_index:
+        print(f"Corpus: {corpus_dir}")
+        print("Snapshot id: (skipped)")
+        return
+
     configuration: dict[str, object] = {}
     if args.retriever in {"embedding-index-file", "embedding-index-inmemory"}:
         configuration["embedding_provider"] = {

{tactus-0.38.0 → tactus-0.40.0}/tactus/__init__.py

@@ -5,7 +5,7 @@ Tactus provides a declarative workflow engine for AI agents with pluggable
 backends for storage, HITL, and chat recording.
 """
 
-__version__ = "0.38.0"
+__version__ = "0.40.0"
 
 # Core exports
 from tactus.core.runtime import TactusRuntime

{tactus-0.38.0 → tactus-0.40.0}/tactus/cli/app.py

@@ -505,6 +505,12 @@ def run(
     real: Optional[list[str]] = typer.Option(
         None, "--real", help="Use real implementation for specific tool(s)"
     ),
+    auto_deps: bool = typer.Option(
+        False, "--auto-deps", help="Automatically run dependency tasks without prompting"
+    ),
+    no_deps: bool = typer.Option(
+        False, "--no-deps", help="Fail fast if dependency tasks are required"
+    ),
     sandbox: Optional[bool] = typer.Option(
         None,
         "--sandbox/--no-sandbox",
@@ -568,6 +574,15 @@ def run(
         console.print(f"[red]Error:[/red] Workflow file not found: {workflow_file}")
         raise typer.Exit(1)
 
+    if not isinstance(auto_deps, bool):
+        auto_deps = False
+    if not isinstance(no_deps, bool):
+        no_deps = False
+
+    if auto_deps and no_deps:
+        console.print("[red]Error:[/red] --auto-deps and --no-deps cannot be combined")
+        raise typer.Exit(1)
+
     # Determine format based on extension
     file_format = "lua" if workflow_file.suffix in [".tac", ".lua"] else "yaml"
 
@@ -808,6 +823,15 @@ def run(
         tool_paths=tool_paths,
         source_file_path=str(workflow_file),
     )
+    runtime.dependency_mode = "auto" if auto_deps else "none" if no_deps else "prompt"
+
+    def _dependency_prompt_handler(plan, label: str) -> bool:
+        pending = [task.kind for task in plan.tasks if task.status != "complete"]
+        pending_summary = ", ".join(pending) if pending else "none"
+        console.print(f"[yellow]Dependencies required for {label}: {pending_summary}[/yellow]")
+        return typer.confirm("Run dependencies now?", default=False)
+
+    runtime.dependency_prompt_handler = _dependency_prompt_handler
 
     # Always create a mock manager so Mocks {} blocks can register tool mocks.
     from tactus.core.mocking import MockManager, set_current_mock_manager

{tactus-0.38.0 → tactus-0.40.0}/tactus/core/dsl_stubs.py

@@ -413,6 +413,17 @@ def create_dsl_stubs(
         # Task "name" { ... }
         if isinstance(name_or_config, str):
             task_name = name_or_config
+            if config is None:
+
+                def _curried(task_config=None):
+                    if task_config is None or not hasattr(task_config, "items"):
+                        raise TypeError(
+                            f"Task '{task_name}' requires a configuration table. "
+                            'Use: Task "name" { ... } or name = Task { ... }.'
+                        )
+                    return _task(task_name, task_config)
+
+                return _curried
             task_config = config or {}
             if hasattr(task_config, "__setitem__"):
                 try:
@@ -450,7 +461,13 @@ def create_dsl_stubs(
             if hasattr(task_config, "items"):
                 child_tasks = {}
                 for key, value in task_config.items():
-                    if isinstance(key, str) and hasattr(value, "items"):
+                    if not (isinstance(key, str) and hasattr(value, "items")):
+                        continue
+                    try:
+                        marker = value["__tactus_task_config"]
+                    except Exception:
+                        marker = False
+                    if marker:
                         child_tasks[key] = value
                 if child_tasks:
                     try: