shynlee04/hivemind-plugin/sequential-orchestration

// NEVER act without checking hierarchy
const hierarchy = scan_hierarchy({ action: "status" })
if (!hierarchy.trajectory) {
  // STOP - Must declare_intent first
  throw new Error("NO ACTION WITHOUT TRAJECTORY")
}

// NEVER trust memory after compaction
const drift = think_back({ mode: "check" })
if (drift.score < 40) {
  // STOP - Context corrupted, must reload
  throw new Error("CONTEXT IMPURE - RELOAD REQUIRED")
}

// NEVER act without verified planning
const plan = recall_mems({ query: "plan" })
if (!plan || plan.length === 0) {
  // STOP - No planning found
  throw new Error("NO ACT WITHOUT SUCCESS RETRIEVAL OF PLANNING")
}

┌─────────────────────────────────────────┐
│  GATE CHECK BEFORE ANY DELEGATION        │
├─────────────────────────────────────────┤
│  [ ] Trajectory exists?                  │
│  [ ] Current tactic defined?             │
│  [ ] Parent node is not stale (>2hr)?    │
│  [ ] No pending failures in brain?       │
│  [ ] Anchors loaded for constraints?     │
└─────────────────────────────────────────┘

// SEQUENTIAL: Await result, retune based on outcome
const result = await task({
  description: "Clear task description",
  prompt: `
    ## Task: [Specific task]
    
    ## Domain: [Which domain - Backend/Frontend/Shared]
    
    ## Boundaries:
    - DO NOT touch: [files/modules outside domain]
    - MUST verify: [quality gates before return]
    
    ## Return Format:
    {
      "outcome": "success" | "partial" | "failure",
      "files_changed": [...],
      "findings": "...",
      "next_recommended": "..." | null
    }
  `,
  subagent_type: "build" // or appropriate agent
})
// AWAIT the result, do not fire-and-forget

// PROCESS result before continuing
if (result.outcome === "success") {
  // Capture intelligence
  export_cycle({
    outcome: "success",
    findings: result.findings
  })
  
  // Update hierarchy
  map_context({ level: "action", content: result.findings })
  
  // PROCEED to next task
} else if (result.outcome === "partial") {
  // RETUNE: Adjust plan based on partial success
  save_mem({
    shelf: "partial_progress",
    content: result.findings,
    tags: "needs-followup"
  })
  
  // REROUTE: Decide next action
  if (result.next_recommended) {
    // Follow agent recommendation
  } else {
    // Ask user for guidance
  }
} else if (result.outcome === "failure") {
  // STOP: Do not continue
  // SAVE state for recovery
  save_anchor({
    key: `failure_${Date.now()}`,
    value: JSON.stringify(result)
  })
  
  // ESCALATE to user
  throw new Error(`DELEGATION FAILED: ${result.findings}`)
}

// BEFORE each delegation, verify domain boundaries
const DOMAIN_BOUNDARIES = {
  backend: {
    allowed: ["src/lib/", "src/tools/", "src/schemas/", "src/hooks/"],
    forbidden: ["dashboard/", "views/", "components/"]
  },
  frontend: {
    allowed: ["src/dashboard/", "src/views/", "src/components/"],
    forbidden: ["src/lib/", "src/tools/", "src/schemas/"]
  },
  shared: {
    allowed: ["src/types/", "src/utils/", "tests/"],
    forbidden: []
  }
}
function checkBoundary(file: string, domain: string): boolean {
  const boundary = DOMAIN_BOUNDARIES[domain]
  const isAllowed = boundary.allowed.some(p => file.startsWith(p))
  const isForbidden = boundary.forbidden.some(p => file.startsWith(p))
  return isAllowed && !isForbidden
}

// CHECK unbroken link before action
function isChainUnbroken(): boolean {
  const ancestors = getAncestors(cursor)
  const expected = ['trajectory', 'tactic', 'action']
  
  // All three levels must be present
  if (ancestors.length < 3) return false
  
  // Each level must have valid content
  return ancestors.every(node => node.content && node.content.length > 0)
}
// IF chain broken → STOP, use map_context to repair
if (!isChainUnbroken()) {
  console.error("CHAIN BROKEN - Cannot proceed")
  // Use think_back to recover context
  // Use map_context to re-establish chain
}

scan_hierarchy({ action: "status" })
recall_mems({ query: "relevant context" })

list_anchors() // Get immutable constraints

// The plan must be retrieved from memory or anchors
// NOT assumed from "I think I remember..."
const plan = recall_mems({ query: "plan trajectory" })

const breaks = detectChainBreaks()
if (breaks.length > 0) {
  // STOP - Chain is broken
}

// Gate check
scan_hierarchy({ action: "status" })
// Context recovery
think_back({ mode: "full" })
// Chain repair
map_context({ level: "tactic", content: "..." })
// Boundary check
grep({ pattern: file, include: allowedPatterns })
// Result capture
export_cycle({ outcome, findings })