# The algo records whose force is control_coordination

This index as JSON: https://banes-lab.com/json/api/facets/algo/force/control-coordination

## Entries

- [Hybrid Workflow Orchestration](https://banes-lab.com/records/algo/hybrid-workflow-orchestration.md): Classify workflow phases by execution verb, run discovery and investigation agents in parallel forked contexts, run action and mutation agents sequentially, and coordinate all agents through shared artifacts and handoff signals.
- [Context Forking Configuration](https://banes-lab.com/records/algo/context-forking-configuration.md): Assign forked context to discovery, investigation, and documentation agents; assign normal context to action and validation agents; preserve model and parallel eligibility metadata per agent class.
- [Verb-Based Execution Classification](https://banes-lab.com/records/algo/verb-based-execution-classification.md): Extract the primary verb from each agent purpose, classify it against parallel or sequential verb sets, and bind execution mode, context, and parallel eligibility.
- [Shared Document Workspace](https://banes-lab.com/records/algo/shared-document-workspace.md): Pre-create workflow documents once, require every agent to read and edit the same documents, prohibit duplicate versions, and enforce single source of truth across phases.
- [Workflow Type Document Selection](https://banes-lab.com/records/algo/workflow-type-document-selection.md): Analyze workflow objective, classify workflow type, select five to eight semantically distinct core documents, and map each document to a non-overlapping purpose.
- [Agent Sequence Definition](https://banes-lab.com/records/algo/agent-sequence-definition.md): For each agent slot, create an agent object with name, type, phase, purpose, methodology, inputs, outputs, validation gates, document responsibilities, focus areas, edit protocol, agent activation, and 4D graph.
- [Agent Activation Invocation](https://banes-lab.com/records/algo/agent-activation-invocation.md): For every agent activation, construct a spawn invocation with agent type, prompt, description, model, and context; use forked context for parallel agents and normal context for sequential agents.
- [Parallel Batch Execution](https://banes-lab.com/records/algo/parallel-batch-execution.md): Accumulate adjacent parallel agents into a batch, invoke all spawns in a single concurrent batch, wait for all completions, and merge findings through shared documents.
- [Sequential Agent Execution](https://banes-lab.com/records/algo/sequential-agent-execution.md): Execute state-changing or validation agents one at a time in normal context, pass handoff context from the previous phase, wait for completion signal, then activate the next agent.
- [Four-Dimensional Agent Graph](https://banes-lab.com/records/algo/four-dimensional-agent-graph.md): For each agent, build sequential dependencies, lateral parallel peers, diagonal artifact/data dependencies, and propagation effects including superseded state, propagated contracts, and breakage risks.
- [Handoff Signal](https://banes-lab.com/records/algo/handoff-signal.md): Require every agent to end with a structured handoff signal containing completed agent, phase status, artifact location, next agent, execution mode, context used, findings, files, validation status, parallel results, 4D graph, and orchestrator action.
- [Orchestrator Action](https://banes-lab.com/records/algo/orchestrator-action.md): Interpret handoff action as activate next agent, pause for the developer, or complete workflow; automatically continue unless a critical decision or repeated recovery failure requires the developer's involvement.
- [Workflow Coordination Sequence](https://banes-lab.com/records/algo/workflow-coordination-sequence.md): Pre-create documents, execute parallel batches where eligible, execute sequential agents one at a time, update checkpoints, validate single source of truth, and mark workflow completion.
- [Checklist Integration](https://banes-lab.com/records/algo/checklist-integration.md): Create a workflow progress checklist in the artifact workspace, include execution model metadata, phases in linear dependency order with severity metadata, task checkboxes, progress bars, success criteria, and agent-edit coordination rules.
- [Phase Documentation Template](https://banes-lab.com/records/algo/phase-documentation-template.md): For each agent phase, render phase header, execution mode, context mode, methodology, 4D graph, artifact flow, focus areas, deliverable, and agent activation example.
- [Template Assembly](https://banes-lab.com/records/algo/template-assembly.md): Assemble frontmatter, workspace config, overview, phase documentation, checklist requirements, orchestration protocol, handoff format, coordination sequence, capability integration, workflow principles, and domain notes into one workflow artifact.
- [Workflow Creation Kernel](https://banes-lab.com/records/algo/workflow-creation-kernel.md): Load DSL and orchestration references, configure file recovery and context forking, discover workspace zones and agents, select shared documents, define dynamic agent sequence, classify execution mode, build 4D graphs, define handoff protocol, assemble coordination sequence, integrate checklist and capabilities, generate phase documentation, assemble template, and validate success criteria.
- [<Workflow Orchestration Concern>](https://banes-lab.com/records/algo/workflow-orchestration-concern.md): <Load orchestration grammar> → <Discover workspace config> → <Select shared documents> → <Define agents> → <Classify parallel vs sequential> → <Fork discovery contexts> → <Serialize action phases> → <Build 4D graphs> → <Create handoff protocol> → <Coordinate shared-document refinement> → <Integrate checklist and capabilities> → <Validate template>
- [Pattern Selection](https://banes-lab.com/records/algo/pattern-selection.md): Select creational, structural, or behavioral patterns based on the problem force: creation variation, interface mismatch, access control, behavior variation, notification, workflow reuse, or coordination complexity.
- [Control Plane Coordination](https://banes-lab.com/records/algo/control-plane-coordination.md): Separate control-plane policy from data-plane execution, centralize configuration, authentication, logging, or orchestration only where shared governance is beneficial, and preserve local autonomy where decentralization is required.
- [Behavioral Dispatch](https://banes-lab.com/records/algo/behavioral-dispatch.md): Externalize variable behavior into strategies, template hooks, observers, or mediators while preserving stable orchestration contracts.
- [Control Plane](https://banes-lab.com/records/algo/control-plane.md): Separate control concerns from data execution, centralize policy/configuration/authentication/logging where beneficial, and decentralize runtime execution where autonomy is required.
- [Automation Opportunity Detection](https://banes-lab.com/records/algo/automation-opportunity-detection.md): Search target scope for manual registries, hardcoded references, static lists, and duplicated discovery logic; then classify each finding with count, location, role, and maintenance signal.
- [Automation Completion Status](https://banes-lab.com/records/algo/automation-completion-status.md): Mark the static-to-dynamic automation complete only when convention strength passed, a manual fallback is preserved, performance and architecture validation passed with measured provenance, and any degraded capability is disclosed; otherwise report planned-only or blocked.
- [<Automation Concern>](https://banes-lab.com/records/algo/automation-concern.md): <Detect static coordination point> → <Classify intentional vs problematic> → <Measure scale pressure> → <Verify convention strength> → <Design dynamic contract> → <Preserve fallback> → <Validate performance and architecture> → <Capture knowledge>
- [Orientation Stage](https://banes-lab.com/records/algo/orientation-stage.md): Establish authority, trust, intent, and change-directionality, and gather current-system evidence before any planning, emitting a context bundle that is the sole artifact the planning stage reads.
- [Teleological Intent Gate](https://banes-lab.com/records/algo/teleological-intent-gate.md): Resolve what the checklist is for before planning it: enumerate the admissible decomposition branches, score each by utility minus cost against the normalized intent and change relation, and gate on the highest-worth admissible branch before any seeing or deriving.
- [Planning Stage](https://banes-lab.com/records/algo/planning-stage.md): Activate the principles that govern the current decision surfaces, select protocols by semantic fit against the requested transition, decompose them into phases, build the four-dimensional graph, and linearize the phases by dependency.
- [Phase Decomposition](https://banes-lab.com/records/algo/phase-decomposition.md): Expand each selected protocol's verb chain into phases, and annotate every phase with an id, verb, objective, preconditions, inputs, outputs, affected artifacts, local principles, severity, loop class, and a four-dimensional graph.
- [Four-Dimensional Phase Graph](https://banes-lab.com/records/algo/four-dimensional-phase-graph.md): For every phase, model the sequential dependency axis, the lateral independent-peer axis, the diagonal shared-data axis, and the propagation axis carrying superseded state, propagated contracts, and what breaks if the edge is omitted.
- [Dependency Linearization](https://banes-lab.com/records/algo/dependency-linearization.md): Detect cycles in the sequential Z-graph, block if any exist, and otherwise order the phases in topological Z-order with a stable tie-breaker so execution order is fixed by dependency alone.
- [Severity Assignment](https://banes-lab.com/records/algo/severity-assignment.md): Derive each phase's severity from the worst severity of its governing principles; severity is per-phase metadata that selects the repair route, while execution order stays linear by dependency.
- [Loop Class Labeling](https://banes-lab.com/records/algo/loop-class-labeling.md): Classify each phase by its verb into a construction, perceptual, cognitive, executive, or linking loop class so the phase's cognitive role is explicit.
- [Compilation Stage](https://banes-lab.com/records/algo/compilation-stage.md): Compile each phase into atomic, target-specific tasks under binding codebase-pattern execution constraints, attach a full nine-dimension named ripple chain to every task, and number the hierarchy N.N.N.
- [Verb Template Binding](https://banes-lab.com/records/algo/verb-template-binding.md): Map each execution verb to a task pattern, a tool set, and a blocking validation command, so a verb becomes a checklist task only through a validated template.
- [Task Atomization](https://banes-lab.com/records/algo/task-atomization.md): Extract atomic, target-specific actions from each phase group, gate every action through the codebase-pattern constraints, and attach an evidence contract, local principle checks, a validation method, and a done-condition to each.
- [Hierarchical Numbering](https://banes-lab.com/records/algo/hierarchical-numbering.md): Render addressable coordinates — Phase N, Task N.N, Subtask N.N.N — assigned only after the phase order is stable.
- [Admissibility Constraint Gate](https://banes-lab.com/records/algo/admissibility-constraint-stage.md): Gate the formalised plan on teleological admissibility before verification: sum the realised cost, compare it to the selected branch's budget and hard limits, and confirm every task traces to the selected branch — an over-budget, limit-breaching, or off-branch plan is inadmissible and routes back rather than being silently accepted.
- [Repair Stage](https://banes-lab.com/records/algo/repair-stage.md): Route every finding to its earliest responsible owner stage, apply the fix, invalidate every dependent record downstream, and re-run from that stage — bounded to a fixed number of cycles, after which the run terminates as blocked with the remaining findings.
- [Bounded Repair Loop](https://banes-lab.com/records/algo/bounded-repair-loop.md): Cap the repair loop at a fixed cycle limit, and on each cycle repair from the earliest invalid stage, invalidate all downstream records, and regenerate them; exceeding the limit sets the run blocked with the remaining findings.
- [Severity Failure Routing](https://banes-lab.com/records/algo/severity-failure-routing.md): Use each finding's severity to choose its repair route — a blocker blocks and repairs, an error repairs, a warning requires a disposition, and anything lower is investigated.
- [Rendering Stage](https://banes-lab.com/records/algo/rendering-stage.md): Serialize only validated records into the checklist deterministically, or render the blocked report, emitting exactly one terminal — success or blocked — with future execution checkboxes left unchecked, and stop within the cycle bound.
- [Explicit Termination](https://banes-lab.com/records/algo/explicit-termination.md): Guarantee the generator stops with exactly one terminal — a written success artifact whose rendering integrity is verified, or a written blocked report — never a premature stop while the status is repairable and never a loop beyond the cycle bound.
- [Cross-Stage Invariants](https://banes-lab.com/records/algo/cross-stage-invariants.md): Bind every stage to the always-and-never rules of the generator — resolve authority and directionality before planning, discover before assuming, activate principles with a bound validator, order by dependency with severity as routing metadata, read only the prior stage's output contract through one evidence-bearing handoff, represent all four graph axes, require evidence for every claim, separate generation gates from future execution gates, repair from the earliest invalid stage, and render deterministically.
- [Checklist Creation Kernel](https://banes-lab.com/records/algo/checklist-creation-kernel.md): Run the six-stage generator in order — orientation, planning, compilation, validation, repair, and rendering — bound by the cross-stage invariants, compiling a task description into a validated, dependency-aware execution checklist or an evidence-bearing blocked report.
- [PAG Explicit Control Flow](https://banes-lab.com/records/algo/pag-explicit-control-flow.md): Express branching with IF / ELSE IF / ELSE, iteration with FOR EACH over a collection (never a bare FOR), and failure handling with TRY / CATCH, every conditional colon-terminated and every branch a complete directive sequence.
- [PAG Structure Declaration](https://banes-lab.com/records/algo/pag-coordination-construct.md): Make a document's structure explicit with the declaration that names it: a DAG for a dependency graph, a STATE_MACHINE for a lifetime or a set of derived states, a PRIORITY_QUEUE for a ranking, a FLOWCHART for the rendered projection of a declared structure, and for a shared surface the coordination model's SURFACE, RECORD and ITEM with their typed edges, derived states and the one post-and-wait operation, so ordering, ownership and state are declared as structure rather than narrated as prose.
- [Behavioral Signature Extraction](https://banes-lab.com/records/algo/behavioral-signature-extraction.md): For each class in a semantic domain, inspect constructor behavior, lifecycle hooks, error handling, state management, dependency acquisition, and public orchestration methods.
- [Temporal Coupling Detection](https://banes-lab.com/records/algo/temporal-coupling-detection.md): Detect must-precede and must-follow ordering constraints between operations in each class, intersect them across the role family, and surface the shared temporal-coupling contract that a base lifecycle would centralize.
- [Concrete-vs-Abstract Responsibility Split](https://banes-lab.com/records/algo/concrete-vs-abstract-responsibility-split.md): Partition the family's behavior into what is invariant across every member (the topology preserved under substitution) and what varies per member (the novelty); the invariant set becomes the concrete base, the variant set becomes the abstract seam. The concrete/abstract boundary is derived from the evidence, not read off a fixed lifecycle vocabulary — so the split holds for any paradigm, not only OOP class lifecycles.