meadow-authoring 0.2.0__py3-none-any.whl

authoring/_application/adapters/haskell/Playground/Vocabulary.hs

@@ -0,0 +1,128 @@
+{- | Stable vocabulary and whole-workflow boundary for the authoring application.
+
+The generated module owns the application's nominal vocabulary. This facade
+retains the literal root 'Task' boundary and the child-process result envelope.
+-}
+module Playground.Vocabulary (
+    -- * Generated vocabulary
+    module Playground.Vocabulary.Generated,
+
+    -- * Workflow operations
+    produce,
+    emit,
+    defaultBound,
+    (<@),
+    (<|>),
+    (<~),
+    (|>),
+    (<||),
+    (||>),
+
+    -- * Whole-workflow execution
+    compileWith,
+    withCompilerConfig,
+    emitOutcome,
+) where
+
+import qualified Data.List.NonEmpty as NE
+import Data.Text (Text)
+import qualified Data.Text as T
+import qualified Data.Text.IO as TIO
+import System.Exit (ExitCode (ExitFailure), exitWith)
+import System.IO (hSetEncoding, hSetNewlineMode, noNewlineTranslation, stderr, stdout, utf8)
+
+import Playground.Vocabulary.Generated
+import Workflow.Algebra.Compile (CompilationInput, CompilationResult (..), workflowYaml)
+import qualified Workflow.Algebra.Compile as Core
+import Workflow.Algebra.CompilerConfig (CompilerConfig, compilerConfig)
+import Workflow.Algebra.Flow (
+    Delivery,
+    Flow,
+    System,
+    defaultBound,
+    emit,
+    produce,
+    (<@),
+    (<|>),
+    (<||),
+    (<~),
+    (|>),
+    (||>),
+ )
+import Workflow.Algebra.Net (
+    ErrorOrigin,
+    OriginPhase,
+    authorPathText,
+    errorOriginAuthorPath,
+    errorOriginPhaseStack,
+    netErrorCode,
+    netFailureCause,
+    netFailureOrigins,
+    originPhaseKind,
+    originPhaseOwner,
+    originPhaseToken,
+    recurrenceOwnerToken,
+    renderNetError,
+ )
+
+compileWith ::
+    (CompilationInput output) =>
+    CompilerConfig ->
+    Flow (Delivery System entry Task) output ->
+    CompilationResult
+compileWith = Core.compileWith
+
+withCompilerConfig :: Integer -> Integer -> (CompilerConfig -> IO ()) -> IO ()
+withCompilerConfig _fanDefault _recurrenceDefault _action =
+    case compilerConfig _fanDefault _recurrenceDefault of
+        Left err -> fail (show err)
+        Right _compilerConfig -> _action _compilerConfig
+
+{- | Emit the closed child-process protocol with UTF-8 and literal LF before any
+result byte; a handle-configuration failure remains an untagged tool failure.
+-}
+emitOutcome :: CompilationResult -> IO ()
+emitOutcome outcome = do
+    hSetEncoding stdout utf8
+    hSetEncoding stderr utf8
+    hSetNewlineMode stdout noNewlineTranslation
+    hSetNewlineMode stderr noNewlineTranslation
+    case outcome of
+        WorkflowCompiled emission ->
+            let yaml = workflowYaml emission
+             in if T.null yaml
+                    then fail "authoring compiler returned empty YAML"
+                    else TIO.hPutStr stdout yaml
+        WorkflowFailed failure -> do
+            let cause = netFailureCause failure
+            TIO.hPutStrLn stderr (T.pack "AUTHORING_NET_ERROR/4")
+            TIO.hPutStrLn stderr (netErrorCode cause)
+            TIO.hPutStrLn stderr (renderOrigins (netFailureOrigins failure))
+            TIO.hPutStrLn stderr (renderNetError cause)
+            exitWith (ExitFailure 20)
+        UnsupportedChoiceProjection _ -> do
+            TIO.hPutStrLn stderr (T.pack "AUTHORING_CAPABILITY/1")
+            TIO.hPutStrLn stderr (T.pack "unsupported_choice_projection")
+            exitWith (ExitFailure 21)
+
+renderOrigins :: NE.NonEmpty ErrorOrigin -> Text
+renderOrigins origins =
+    T.pack "[" <> T.intercalate (T.pack ",") (fmap renderOrigin (NE.toList origins)) <> T.pack "]"
+
+renderOrigin :: ErrorOrigin -> Text
+renderOrigin origin =
+    T.pack "{\"path\":\""
+        <> authorPathText (errorOriginAuthorPath origin)
+        <> T.pack "\",\"phases\":["
+        <> T.intercalate
+            (T.pack ",")
+            (fmap renderPhase (errorOriginPhaseStack origin))
+        <> T.pack "]}"
+
+renderPhase :: OriginPhase -> Text
+renderPhase phase =
+    T.pack "{\"phase\":\""
+        <> originPhaseToken (originPhaseKind phase)
+        <> T.pack "\",\"owner\":\""
+        <> recurrenceOwnerToken (originPhaseOwner phase)
+        <> T.pack "\"}"

authoring/_application/adapters/haskell/ValidateConfig.hs

@@ -0,0 +1,27 @@
+module Main (main) where
+
+import System.Environment (getArgs)
+import System.Exit (ExitCode (ExitFailure), exitWith)
+import System.IO (hPutStrLn, stderr)
+import Text.Read (readMaybe)
+
+import Workflow.Algebra.CompilerConfig (
+    compilerConfig,
+    compilerFanDefault,
+    compilerRecurrenceDefault,
+ )
+
+main :: IO ()
+main = do
+    args <- getArgs
+    case traverse readMaybe args of
+        Just [fanDefault, recurrenceDefault] ->
+            case compilerConfig fanDefault recurrenceDefault of
+                Left err -> hPutStrLn stderr (show err) >> exitWith (ExitFailure 22)
+                Right config ->
+                    putStrLn
+                        ( show (compilerFanDefault config)
+                            ++ ","
+                            ++ show (compilerRecurrenceDefault config)
+                        )
+        _ -> fail "expected two integer compiler defaults"

authoring/_application/config/diagnostic-messages.json

@@ -0,0 +1,80 @@
+{
+  "schema_version": 1,
+  "local": {
+    "empty_expression": "Enter an expression.",
+    "document_limit": "Document exceeds the authoring limit {limit} UTF-16 code units.",
+    "syntax_error": "Expression has invalid syntax.",
+    "unknown_actor": "Unknown actor '{name}'.",
+    "unknown_message": "Unknown message noun '{name}'.",
+    "wrong_noun_role": "Noun '{name}' is not valid in {position} position.",
+    "natural_limit": "Natural exceeds the authoring limit {limit}.",
+    "ast_node_limit": "Expression exceeds the authoring limit {limit} constructors.",
+    "ast_depth_limit": "Expression exceeds the authoring limit {limit} constructor levels.",
+    "elaborated_flow_node_limit": "Expression exceeds the authoring limit {limit} elaborated Flow constructors."
+  },
+  "workflow": {
+    "non_positive_fan_bound": "A fan bound of zero dispatches nothing: {token:QuantifierOperator} must be positive.",
+    "empty_fan_child": "A fan's repeated child cannot be empty: it must contain at least one operation.",
+    "duplicate_completion_dispatch_key": "Two fan completions share one dispatch key (owner {owner}, input {input}, dispatch {dispatch}).",
+    "duplicate_completion_id": "Two distinct fan completions join to one canonical id '{completion_id}' under the underscore-joined id scheme.",
+    "coincident_back_forward": "Emission key {emission} projects one materialized recurrence cell's Back and Forward alternatives to route {route}; one TMC route counter cannot distinguish them.",
+    "conflicting_emission_policy": "Emission key {emission} receives incompatible complete policies from one or more physical sites; one WCP handler or selector key cannot represent them.",
+    "conflicting_route_policy": "Route {route} receives incompatible complete global policies; one WCP route row cannot represent them.",
+    "conflicting_bounded_owners": "Route {route} is shared by incompatible bounded-owner uses in one possible work scope; one TMC route counter cannot preserve their allowances.",
+    "conflicting_scoped_traversal_demand": "Route {route} carries incompatible traversal requirements ({low} and {high}) across work scopes; WCP has one max_traversals value per route.",
+    "empty_workflow": "An operation-free workflow has no projection: a workflow needs an entry actor, a root task route, and a terminal route.",
+    "invalid_root_message": "The root delivery must carry the literal wire name 'task'; this workflow starts with '{wire}'.",
+    "reserved_actor_name": "Actor wire name '{wire}' is reserved for the system endpoint.",
+    "domain_control_collision": "Domain wire name '{wire}' collides with the reserved control vocabulary.",
+    "non_injective_actor_name": "Two distinct actor types reflect to one wire name '{wire}'.",
+    "non_injective_message_name": "Two distinct message types reflect to one wire name '{wire}'.",
+    "unsafe_actor_name": "Actor wire name '{wire}' falls outside the restricted scalar grammar [a-z][a-z0-9_]*.",
+    "unsafe_message_name": "Message wire name '{wire}' falls outside the restricted scalar grammar [a-z][a-z0-9_]*."
+  },
+  "authoring": {
+    "ast_node_count": "ast_node_count exceeds the authoring limit {limit}.",
+    "ast_depth": "ast_depth exceeds the authoring limit {limit}.",
+    "elaborated_flow_node_count": "elaborated_flow_node_count exceeds the authoring limit {limit}.",
+    "max_items": "Dispatch {token:QuantifierOperator} exceeds the authoring limit {limit}.",
+    "max_revisions": "Choice {token:QuantifierOperator} exceeds the authoring limit {limit}.",
+    "document_length_utf16": "document_length_utf16 exceeds the authoring limit {limit}.",
+    "prompt": "Prompt exceeds the authoring limit {limit} at '/prompt'.",
+    "expression": "Expression exceeds the authoring limit {limit} at '/expression'."
+  },
+  "service": {
+    "ghc_type_error": "Mismatch between expected and actual Actors. Actual: {actual}  Expected: {expected}. (GHC-83865)",
+    "tool_protocol_error": "The compiler returned an invalid result envelope.",
+    "tool_process_error": "The compiler process failed outside the authored expression.",
+    "tool_output_limit": "Compiler output exceeded {limit} bytes.",
+    "tool_configuration_error": "The complete team configuration is unavailable.",
+    "tool_unavailable": "The local authoring compiler is unavailable.",
+    "tool_timeout": "Compilation exceeded {limit} seconds.",
+    "tool_busy": "Another compilation is already running.",
+    "run_busy": "Another Meadow run is already running.",
+    "invalid_json": "Request body is not valid JSON.",
+    "invalid_envelope": "Request envelope is invalid at '{pointer}'.",
+    "invalid_envelope_detail": "Request envelope is invalid at '{pointer}': {problem}",
+    "invalid_ast": "Raw AST is invalid at '{pointer}'.",
+    "request_too_large": "Request body exceeds {limit} bytes.",
+    "yaml_override_invalid_yaml": "yaml_override is not valid YAML.",
+    "yaml_override_not_mapping": "yaml_override is not a single YAML mapping.",
+    "yaml_override_missing_workflow": "yaml_override has no top-level 'workflow' key.",
+    "directory_not_found": "The selected directory does not exist.",
+    "not_a_directory": "The selected path is not a directory.",
+    "directory_unreadable": "The selected directory cannot be read.",
+    "dsl_expression_default_not_found": "The default DSL expression file is not present.",
+    "dsl_expression_default_unreadable": "The default DSL expression file cannot be read.",
+    "dsl_expression_default_not_utf8": "The default DSL expression file is not valid UTF-8.",
+    "theme_not_found": "The highlight theme file is not present.",
+    "theme_unreadable": "The highlight theme file cannot be read.",
+    "theme_not_utf8": "The highlight theme file is not valid UTF-8.",
+    "theme_unavailable": "The highlight theme endpoint is unavailable.",
+    "theme_not_applied": "The highlight theme was not applied: {reason}",
+    "invalid_target": "The selected target is not a configured Git repository.",
+    "meadow_unavailable": "The Meadow executable is unavailable.",
+    "meadow_process_error": "The Meadow process could not be completed.",
+    "unknown_request": "The requested run is unknown.",
+    "unsupported_choice_projection": "Choice output has no supported projection in this delivery.",
+    "ghc_boundary_type_error": "Expression has incompatible workflow boundaries. ({code})"
+  }
+}

authoring/_application/config/dsl-expression-default.canonical.txt

@@ -0,0 +1,10 @@
+ExplorerOrchestrator -> ExplorationRequest
+  [[ Explorer -> ExplorationResponse
+  ]> WorldModel
+|> Planner -> Plan
+   <~ Reviewer -> RevisionRequest | Plan
+|> ImplementerOrchestrator -> CheckpointRequest
+     [[ Implementer -> CheckpointImplementation
+        <~ CheckpointReviewer -> CheckpointRevisionRequest | CheckpointImplementation
+     ]> Implementation
+   <~ ComprehensiveReviewer -> WorkRequired | Implementation

authoring/_application/config/invocation-policy.yaml

@@ -0,0 +1,11 @@
+schema_version: 1
+reset_on: {}
+
+# To enable resets, replace reset_on: {} with a mapping like this:
+# reset_on:
+#   Implementer:
+#     - CheckpointRevisionRequest
+#     - RevisionRequest
+# Actor and message names must match vocabulary.json exactly.
+# Each matching handler starts from initial actor state on every invocation.
+# Restart the authoring application after editing this file; vocabulary regeneration is unnecessary.

authoring/_application/config/operational-settings.json

@@ -0,0 +1,23 @@
+{
+  "schema_version": 1,
+  "max_request_bytes": 65536,
+  "max_json_container_depth": 64,
+  "max_document_length_utf16": 65536,
+  "max_ast_nodes": 256,
+  "max_ast_depth": 32,
+  "max_elaborated_flow_nodes": 1280,
+  "max_natural": 9007199254740991,
+  "max_output_bytes": 1048576,
+  "timeout_seconds": 30,
+  "wasm_startup_timeout_seconds": 120,
+  "kill_grace_seconds": 2,
+  "max_concurrent_compiles": 1,
+  "max_queued_compiles": 0,
+  "max_prompt_codepoints": 65000,
+  "max_expression_codepoints": 65536,
+  "max_run_log_slice_bytes": 65536,
+  "max_concurrent_runs": 4,
+  "max_retained_exited_runs": 32,
+  "run_log_directory": null,
+  "wasm_cache_directory": null
+}

authoring/_application/config/surface-defaults.json

@@ -0,0 +1,7 @@
+{
+  "schema_version": 2,
+  "defaults": {
+    "fan": 3,
+    "recurrence": 6
+  }
+}

authoring/_application/config/surface-theme.json

@@ -0,0 +1,17 @@
+{
+  "schema_version": 1,
+  "roles": {
+    "produce": { "color": "#a6a6a6", "weight": 400, "style": "normal" },
+    "recur": { "color": "#ffd566", "weight": 800, "style": "normal" },
+    "pipe": { "color": "#ffd566", "weight": 800, "style": "normal" },
+    "fanOpen": { "color": "#d692e0", "weight": 400, "style": "normal" },
+    "fanClose": { "color": "#d692e0", "weight": 400, "style": "normal" },
+    "quantifier": { "color": "#9ebeff", "weight": 650, "style": "normal" },
+    "choice": { "color": "#9ebeff", "weight": 650, "style": "normal" },
+    "actor": { "color": "#7ddcb0", "weight": 650, "style": "normal" },
+    "message": { "color": "#9ebeff", "weight": 650, "style": "normal" },
+    "natural": { "color": "#cdaaff", "weight": 400, "style": "normal" },
+    "grouping": { "color": "#a6a6a6", "weight": 400, "style": "normal" },
+    "comment": { "color": "#808080", "weight": 400, "style": "italic" }
+  }
+}

authoring/_application/config/surface-tokens.json

@@ -0,0 +1,37 @@
+{
+  "schema_version": 1,
+  "tokens": {
+    "PipeOperator": {
+      "haskell": "|>",
+      "surface": "=>"
+    },
+    "RecurOperator": {
+      "haskell": "<~",
+      "surface": "<~"
+    },
+    "FanOpenDelimiter": {
+      "haskell": "<||",
+      "surface": "<<"
+    },
+    "FanCloseDelimiter": {
+      "haskell": "||>",
+      "surface": ">>"
+    },
+    "ProduceKeyword": {
+      "haskell": "produce",
+      "surface": "->"
+    },
+    "QuantifierOperator": {
+      "haskell": "<@",
+      "surface": "@"
+    },
+    "ChoiceOperator": {
+      "haskell": "<|>",
+      "surface": "|"
+    },
+    "LineComment": {
+      "haskell": "--",
+      "surface": "--"
+    }
+  }
+}

authoring/_application/config/team-yaml-default-prelude.yaml

@@ -0,0 +1,167 @@
+# **This is compiled YAML**
+# You may edit this YAML before running the workflow,
+# but editing the associated workflow language
+# expression will trigger a recompile and overwrite
+# any changes you may have made.
+
+project:
+  lint_commands: []
+  build_commands: []
+  test_commands: []
+  memory_globs:
+    - README.md
+    - AGENTS.md
+    - CODING_STANDARDS.md
+    - RIGOR.md
+#  setup_script: ${MEADOW_SETUP_SCRIPT}
+
+roles:
+   default:
+      provider_id: meadow_bridge
+      model_id: gpt-5.6-luna
+      variant: low
+      concurrency: 20
+#   reviewer:
+#      actor: reviewer
+#      provider_id: meadow_bridge
+#      model_id: gpt-5.6-sol
+#      variant: max
+#      concurrency: 16
+#   explorerorchestrator:
+#      actor: explorerorchestrator
+#      provider_id: meadow_bridge
+#      model_id: gpt-5.6-terra
+#      variant: max
+#      concurrency: 16
+#   explorer:
+#      actor: explorer
+#      provider_id: meadow_bridge
+#      model_id: gpt-5.6-terra
+#      variant: xhigh
+#      concurrency: 16
+#   verticalplanner:
+#      actor: verticalplanner
+#      provider_id: meadow_bridge
+#      model_id: gpt-5.6-sol
+#      variant: max
+#      concurrency: 16
+#   implementer:
+#      actor: implementer
+#      provider_id: meadow_bridge
+#      model_id: gpt-5.6-sol
+#      variant: max
+#      concurrency: 16
+#   implementerorchestrator:
+#      actor: implementerorchestrator
+#      provider_id: meadow_bridge
+#      model_id: gpt-5.6-sol
+#      variant: xhigh
+#      concurrency: 1
+#   planner:
+#      actor: planner
+#      provider_id: meadow_bridge
+#      model_id: gpt-5.6-sol
+#      variant: max
+#      concurrency: 16
+#   writer:
+#      actor: writer
+#      provider_id: meadow_bridge
+#      model_id: gpt-5.6-terra
+#      variant: high
+#      concurrency: 16
+#   verticalorchestrator:
+#      actor: verticalorchestrator
+#      provider_id: meadow_bridge
+#      model_id: gpt-5.6-terra
+#      variant: xhigh
+#      concurrency: 16
+#   finalreviewer:
+#      actor: finalreviewer
+#      provider_id: meadow_bridge
+#      model_id: gpt-5.6-sol
+#      variant: xhigh
+#      concurrency: 16
+#   reviewerorchestrator:
+#      actor: reviewerorchestrator
+#      provider_id: meadow_bridge
+#      model_id: gpt-5.6-sol
+#      variant: xhigh
+#      concurrency: 16
+#   requirementsanalyst:
+#      actor: requirementsanalyst
+#      provider_id: meadow_bridge
+#      model_id: gpt-5.6-sol
+#      variant: max
+#      concurrency: 16
+#   testauthor:
+#      actor: testauthor
+#      provider_id: meadow_bridge
+#      model_id: gpt-5.6-sol
+#      variant: max
+#      concurrency: 16
+#   sequentialorchestrator:
+#      actor: sequentialorchestrator
+#      provider_id: meadow_bridge
+#      model_id: gpt-5.6-terra
+#      variant: high
+#      concurrency: 1
+#   orchestrator:
+#      actor: orchestrator
+#      provider_id: meadow_bridge
+#      model_id: gpt-5.6-terra
+#      variant: max
+#      concurrency: 4
+#   plannerorchestrator:
+#      actor: plannerorchestrator
+#      provider_id: meadow_bridge
+#      model_id: gpt-5.6-sol
+#      variant: max
+#      concurrency: 4
+
+providers: {}
+#  zai-coding-plan:
+#    type: api
+#    env_key: MEADOW_ZHIPU_API_KEY
+#    opencode_key: ZHIPU_API_KEY
+#  moonshotai:
+#    type: api
+#    env_key: MEADOW_MOONSHOT_API_KEY
+#    opencode_key: MOONSHOT_API_KEY
+#  kimi-for-coding:
+#    type: api
+#    env_key: MEADOW_KIMI_API_KEY
+#    opencode_key: KIMI_API_KEY
+#  anthropic:
+#    type: api
+#    env_key: MEADOW_ANTHROPIC_API_KEY
+#    opencode_key: ANTHROPIC_API_KEY
+#  openai:
+#    type: oauth
+
+meadow_bridge:
+  max_command_duration_s: 1800
+  max_prompt_duration_s: 2400
+  capture_raw_events: true
+
+opencode:
+  timeout_s: 900
+#  container_image: localhost/meadow-opencode:1.18.31
+
+embeddings:
+  enabled: false
+#  base_url:
+#  api_key: ${MEADOW_EMBEDDING_API_KEY}
+#  model: qwen3-embedding-4b
+#  dimensions:
+
+vector_store:
+  enabled: false
+#  chunk_size: 1400
+#  chunk_overlap: 200
+#  top_k: 8
+
+scribe:
+  enabled: false
+#  provider_id: ${MEADOW_DEFAULT_SCRIBE_PROVIDER_ID}
+#  model_id: ${MEADOW_DEFAULT_SCRIBE_MODEL_ID}
+#  variant: ${MEADOW_DEFAULT_SCRIBE_MODEL_VARIANT}

authoring/_application/config/vocabulary.json

@@ -0,0 +1,79 @@
+{
+  "schema_version": 3,
+  "actors": [
+    "Architect",
+    "CheckpointReviewer",
+    "ComprehensiveReviewer",
+    "Explorer",
+    "ExplorerOrchestrator",
+    "Implementer",
+    "ImplementerOrchestrator",
+    "Investigator",
+    "Loop",
+    "Orchestrator",
+    "Planner",
+    "PlannerOrchestrator",
+    "RequirementsAnalyst",
+    "ReviewerOrchestrator",
+    "Reviewer",
+    "TestAuthor",
+    "VerticalPlanner",
+    "VerticalOrchestrator",
+    "Writer",
+    "ActorA",
+    "ActorB",
+    "ActorC",
+    "ActorD",
+    "ActorE",
+    "ActorF"
+  ],
+  "messages": [
+    "Analysis",
+    "Architecture",
+    "Assignments",
+    "CompletedSlice",
+    "Design",
+    "Document",
+    "CheckpointRequest",
+    "CheckpointImplementation",
+    "Checkpoint",
+    "CheckpointRevisionRequest",
+    "ExplorationRequest",
+    "ExplorationResponse",
+    "ExplorationResult",
+    "ExplorationTask",
+    "Implementation",
+    "ImplementationWork",
+    "Next",
+    "NotAllCheckpointsComplete",
+    "Plan",
+    "PlanRequest",
+    "PlanResponse",
+    "PlanningSlice",
+    "Request",
+    "Requirements",
+    "Result",
+    "RevisionRequest",
+    "Review",
+    "ReviewRequest",
+    "ReviewResponse",
+    "RootCause",
+    "SemanticIndex",
+    "Specification",
+    "Subtask",
+    "Subtasks",
+    "Task",
+    "Tests",
+    "WorkRequired",
+    "WorkItem",
+    "WorkItems",
+    "WorldModel",
+    "MessageA",
+    "MessageB",
+    "MessageC",
+    "MessageD",
+    "MessageE",
+    "MessageF",
+    "MessageG"
+  ]
+}